Merge bea8f291bc into 01771b39c9

.github/workflows/lint.yml

@@ -22,7 +22,22 @@ jobs:
 
       - name: Files are UTF-8
         run: ./lint/encoding.sh .
+      - name: "No non-breaking spaces"
+        run: |
+          if grep -rI --include='*.md' $'\u00A0' .; then
+            exit 1
+          fi
+      - name: "No zero-width spaces"
+        run: |
+          if grep -rI --include='*.md' $'\u200B' .; then
+            exit 1
+          fi
+      - name: "No carriage return"
+        run: |
+          if grep -rI --include='*.md' $'\u000D' .; then
+            exit 1
+          fi
       - name: Lint Markdown
-        run: mdl . --ignore-front-matter -r MD003,MD011,MD023,MD027,MD028,MD035,MD037,MD038,MD039,MD047
+        run: mdl . --ignore-front-matter -r MD003,MD005,MD011,MD018,MD019,MD023,MD025,MD027,MD028,MD030,MD035,MD037,MD038,MD039,MD047
       - name: Lint frontmatter
         run: ./lint/frontmatter.py .

ansible.md

@@ -352,7 +352,7 @@ Get familiar with how you can use roles in the simple_apache_role example
 ```
 playbooks/roles/simple_apache_role/
 ├── tasks
-│   └── main.yml
+│   └── main.yml
 └── templates
     └── main.yml
 ```

bash.md

@@ -343,7 +343,7 @@ echo "#helloworld" | tee output.out >/dev/null
 rm -v output.out error.err output-and-error.log
 rm -r tempDir/ # recursively delete
 # You can install the `trash-cli` Python package to have `trash`
-# which puts files in the system trash and doesn't delete them directly
+# which puts files in the system trash and doesn't delete them directly
 # see https://pypi.org/project/trash-cli/ if you want to be careful
 
 # Commands can be substituted within other commands using $( ):
@@ -360,7 +360,7 @@ case "$Variable" in
     # List patterns for the conditions you want to meet
     0) echo "There is a zero.";;
     1) echo "There is a one.";;
-    *) echo "It is not null.";;  # match everything
+    *) echo "It is not null.";;  # match everything
 esac
 
 # `for` loops iterate for as many arguments given:
@@ -462,8 +462,8 @@ cut -d ',' -f 1 file.txt
 # replaces every occurrence of 'okay' with 'great' in file.txt
 # (regex compatible)
 sed -i 's/okay/great/g' file.txt
-# be aware that this -i flag means that file.txt will be changed
-# -i or --in-place erase the input file (use --in-place=.backup to keep a back-up)
+# be aware that this -i flag means that file.txt will be changed
+# -i or --in-place erase the input file (use --in-place=.backup to keep a back-up)
 
 # print to stdout all lines of file.txt which match some regex
 # The example prints lines which begin with "foo" and end in "bar"

bg/logtalk.md

@@ -4,7 +4,6 @@ contributors:
     - ["Paulo Moura", "http://github.com/pmoura"]
 translators:
     - ["vsraptor", "https://github.com/vsraptor"]
-
 ---
 
 Logtalk е обектно-ориентиран (ОО) модерен логически език за програмиране, които разширява Prolog с възможности за капсулиране (еncapsulation) и многократно използване на кода без да компрометира декларативните възможности на езика. Logtalk е имплементиран така че да може да бъде адапртиран към всеки стандартен Prolog като back-end компилатор, тоест е напълно прозрачен за нормална Prolog програма.
@@ -23,9 +22,9 @@ Logtalk използва стандартен Prolog синтакс, с мини
 
 Операторите които Logtalk добавя към Prolog са :
 
-    ::/2 - изпраща саобщение до обект (аналогично на метод в стандартните ООП езици)
-    ::/1 - изпраща саобщение до себе си (self) (тоест до обекта който е получил съобщението което обработваме в момента)
-    ^^/1 - super call (изпраща саобщение до наследен или импортиран предикат(predicate))
+* `::/2` - изпраща саобщение до обект (аналогично на метод в стандартните ООП езици)
+* `::/1` - изпраща саобщение до себе си (*self*) (тоест до обекта който е получил съобщението което обработваме в момента)
+* `^^/1` - *super* call (изпраща саобщение до наследен или импортиран предикат(predicate))
 
 
 ## Entities and roles (Субекти и роли)

cobol.md

@@ -186,7 +186,7 @@ organizations.
       THE FULL NAME IS: BOB GIBBERISH COBB
 ```
 
-##Ready For More?
+## Further reading
 
 * [GnuCOBOL](https://sourceforge.net/projects/open-cobol/)
 

cs/python.md

@@ -610,7 +610,7 @@ for nasobek in nasobicka_2([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]):
         break
 
 # Funkce range() je také generátor - vytváření seznamu 900000000 prvků by zabralo
-# hodně času i paměti, proto se místo toho čísla generují postupně.
+# hodně času i paměti, proto se místo toho čísla generují postupně.
 for nasobek in nasobicka_2(range(900000000)):
     # Vypíše postupně: "Zpracovávám číslo 1",  ...,  "Zpracovávám číslo 5"
     if nasobek >= 10:

csharp.md

@@ -1314,6 +1314,7 @@ namespace Csharp7
 ```
 
 ## Topics Not Covered
+
 ✨ New, 👍 Old, 🎈 LTS, 🔥 Cross-platform, 🎁 Windows-only
 
 * Attributes
@@ -1335,7 +1336,6 @@ namespace Csharp7
     * Xamarin.Forms 👍
     * MAUI ✨
 
-
 ## Further Reading
 
 * [C# language reference](https://docs.microsoft.com/dotnet/csharp/language-reference/)
@@ -1347,4 +1347,3 @@ namespace Csharp7
 * [LINQ Pocket Reference](http://shop.oreilly.com/product/9780596519254.do)
 * [Windows Forms Programming in C#](http://www.amazon.com/Windows-Forms-Programming-Chris-Sells/dp/0321116208)
 * [freeCodeCamp - C# Tutorial for Beginners](https://www.youtube.com/watch?v=GhQdlIFylQ8)
- 

css.md

@@ -224,13 +224,13 @@ body {
 
 /* Nest style rule inside another (CSS 3) */
 .main {
-   .bgred { /* same as: .main .bgred { } */
+   .bgred { /* same as: .main .bgred { } */
       background: red;
    }
    & .bggreen { /* same as: .main .bggreen { } */
       background: green;
    }
-   &.bgblue { /* (without space) same as: .main.bgblue { } */
+   &.bgblue { /* (without space) same as: .main.bgblue { } */
       background: blue;
    }
 }

cue.md

@@ -488,12 +488,12 @@ To make it concrete, consider the following:
 ```
 mymodule
 ├── config
-│   ├── a.cue
-│   └── b.cue
+│   ├── a.cue
+│   └── b.cue
 ├── cue.mod
-│   ├── module.cue
-│   ├── pkg
-│   └── usr
+│   ├── module.cue
+│   ├── pkg
+│   └── usr
 └── main.cue
 ```
 

de/pythonlegacy.md

@@ -461,18 +461,18 @@ class Human(object):
         return "*grunt*"
 
     # Eine Eigenschaft (Property) ist wie ein Getter.
-    # Es verwandelt die Methode age() in ein schreibgeschütztes Attribut mit demselben Namen.
-    # Es ist jedoch nicht nötig, triviale Getter und Setter in Python zu schreiben.
+    # Es verwandelt die Methode age() in ein schreibgeschütztes Attribut mit demselben Namen.
+    # Es ist jedoch nicht nötig, triviale Getter und Setter in Python zu schreiben.
     @property
     def age(self):
         return self._age
 
-    # Damit kann die Eigenschaft festgelegt werden
+    # Damit kann die Eigenschaft festgelegt werden
     @age.setter
     def age(self, age):
         self._age = age
 
-    # Damit kann die Eigenschaft gelöscht werden
+    # Damit kann die Eigenschaft gelöscht werden
     @age.deleter
     def age(self):
         del self._age
@@ -561,7 +561,7 @@ class Superhero(Human):
         # Mit der Funktion "super" können Sie auf die Methoden der übergeordneten Klasse 
         # zugreifen, die vom untergeordneten Objekt überschrieben werden, 
         # in diesem Fall die Methode __init__.
-        # Dies ruft den Konstruktor der übergeordneten Klasse auf:
+        # Dies ruft den Konstruktor der übergeordneten Klasse auf:
         super().__init__(name)
         
     # überschreiben der "sing" Methode
@@ -583,7 +583,7 @@ if __name__ == '__main__':
         print('I am a superhero')
         
     # Die Reihenfolge der Methodenauflösung (MRO = Method Resolution Order) anzeigen, die sowohl von getattr() als auch von super() verwendet wird.
-    # Dieses Attribut ist dynamisch und kann aktualisiert werden.
+    # Dieses Attribut ist dynamisch und kann aktualisiert werden.
     print(Superhero.__mro__)    # => (<class '__main__.Superhero'>,
                                 # => <class 'human.Human'>, <class 'object'>)
                                 

el/python.md

@@ -523,7 +523,7 @@ next(our_iterator)  # => "one"
 next(our_iterator)  # => "two"
 next(our_iterator)  # => "three"
 
-# Όταν ο iterator έχει επιστρέψει όλα τα δεδομένα του, προκαλεί ένα μια εξαίρεση StopIteration.
+# Όταν ο iterator έχει επιστρέψει όλα τα δεδομένα του, προκαλεί ένα μια εξαίρεση StopIteration.
 next(our_iterator)  # προκαλεί StopIteration
 
 # Μπορείς να πάρεις όλα τα αντικείμενα ενός iteratior καλώντας list() πάνω του.

es/c++.md

@@ -280,7 +280,7 @@ foo(bar(tempObjectFun()))
 
 void constReferenceTempObjectFun() {
   // ConstRef obtiene el objeto temporal, y es válido hasta el final de esta
-  // función.
+  // función.
   const string& constRef = tempObjectFun();
   ...
 }
@@ -328,10 +328,10 @@ public:
     Dog();
 
 	// Declaraciones de funciones de la clase (implementaciones a seguir)
-    // Nota que usamos std::string aquí en lugar de colocar
-    // using namespace std;
-    // arriba.
-    // Nunca ponga una declaración "using namespace" en un encabezado.
+    // Nota que usamos std::string aquí en lugar de colocar
+    // using namespace std;
+    // arriba.
+    // Nunca ponga una declaración "using namespace" en un encabezado.
     void setName(const std::string& dogsName);
 
     void setWeight(int dogsWeight);
@@ -471,7 +471,7 @@ public:
     Point& operator+=(const Point& rhs);
 
     // También tendría sentido añadir los operadores - y -=,
-   	// pero vamos a omitirlos por razones de brevedad.
+   	// pero vamos a omitirlos por razones de brevedad.
 };
 
 Point Point::operator+(const Point& rhs) const

es/fsharp.md

@@ -248,7 +248,7 @@ module EjemploDeSecuencia =
     let secuencia1 = seq { yield "a"; yield "b" }
 
     // Las secuencias pueden usar yield y
-    // puede contener subsecuencias
+    // puede contener subsecuencias
     let extranio = seq {
         // "yield" agrega un elemento
         yield 1; yield 2;
@@ -262,7 +262,7 @@ module EjemploDeSecuencia =
     extranio |> Seq.toList
 
     // Las secuencias se pueden crear usando "unfold"
-    // Esta es la secuencia de fibonacci
+    // Esta es la secuencia de fibonacci
     let fib = Seq.unfold (fun (fst,snd) ->
         Some(fst + snd, (snd, fst + snd))) (0,1)
 
@@ -278,8 +278,8 @@ module EejemploDeTipoDeDatos =
 
     // Todos los datos son inmutables por defecto
 
-     // las tuplas son tipos anónimos simples y rápidos
-     // - Usamos una coma para crear una tupla
+     // las tuplas son tipos anónimos simples y rápidos
+     // - Usamos una coma para crear una tupla
     let dosTuplas = 1,2
     let tresTuplas = "a",2,true
 
@@ -301,7 +301,7 @@ module EejemploDeTipoDeDatos =
 
     // ------------------------------------
     // Los tipos de unión (o variantes) tienen un conjunto de elección
-     // Solo un caso puede ser válido a la vez.
+     // Solo un caso puede ser válido a la vez.
     // ------------------------------------
 
     // Usamos "type" con barra/pipe para definir una unión estándar
@@ -326,7 +326,7 @@ module EejemploDeTipoDeDatos =
     // ------------------------------------
 
     // Los tipos se pueden combinar recursivamente de formas complejas
-    // sin tener que crear subclases
+    // sin tener que crear subclases
     type Empleado =
       | Trabajador of Persona
       | Gerente of Empleado lista
@@ -349,9 +349,9 @@ module EejemploDeTipoDeDatos =
         | DireccionDeCorreoInvalido direccion -> () // no enviar
 
     // Combinar juntos, los tipos de unión y tipos de registro
-     // ofrece una base excelente para el diseño impulsado por el dominio.
-     // Puedes crear cientos de pequeños tipos que reflejarán fielmente
-     // el dominio.
+     // ofrece una base excelente para el diseño impulsado por el dominio.
+     // Puedes crear cientos de pequeños tipos que reflejarán fielmente
+     // el dominio.
 
     type ArticuloDelCarrito = { CodigoDelProducto: string; Cantidad: int }
     type Pago = Pago of float
@@ -368,17 +368,17 @@ module EejemploDeTipoDeDatos =
     // ------------------------------------
 
     // Los tipos nativos tienen el comportamiento más útil "listo para usar", sin ningún código para agregar.
-     // * Inmutabilidad
-     // * Bonita depuración de impresión
-     // * Igualdad y comparación
-     // * Serialización
+     // * Inmutabilidad
+     // * Bonita depuración de impresión
+     // * Igualdad y comparación
+     // * Serialización
 
-     // La impresión bonita se usa con %A
+     // La impresión bonita se usa con %A
     printfn "dosTuplas=%A,\nPersona=%A,\nTemp=%A,\nEmpleado=%A"
              dosTuplas persona1 temp1 trabajador
 
     // La igualdad y la comparación son innatas
-     // Aquí hay un ejemplo con tarjetas.
+     // Aquí hay un ejemplo con tarjetas.
     type JuegoDeCartas = Trebol | Diamante | Espada | Corazon
     type Rango = Dos | Tres | Cuatro | Cinco | Seis | Siete | Ocho
                 | Nueve | Diez | Jack | Reina | Rey | As
@@ -398,11 +398,11 @@ module EejemploDeTipoDeDatos =
 module EjemplosDePatronesActivos =
 
     // F# tiene un tipo particular de coincidencia de patrón llamado "patrones activos"
-    // donde el patrón puede ser analizado o detectado dinámicamente.
+    // donde el patrón puede ser analizado o detectado dinámicamente.
 
-    // "clips de banana" es la sintaxis de los patrones activos
+    // "clips de banana" es la sintaxis de los patrones activos
 
-    // por ejemplo, definimos un patrón "activo" para que coincida con los tipos de "caracteres" ...
+    // por ejemplo, definimos un patrón "activo" para que coincida con los tipos de "caracteres" ...
     let (|Digito|Latra|EspacioEnBlanco|Otros|) ch =
        if System.Char.IsDigit(ch) then Digito
        else if System.Char.IsLetter(ch) then Letra
@@ -425,7 +425,7 @@ module EjemplosDePatronesActivos =
     // -----------------------------------------
 
     // Puede crear un patrón de coincidencia parcial también
-    // Solo usamos un guión bajo en la definición y devolvemos Some si coincide.
+    // Solo usamos un guión bajo en la definición y devolvemos Some si coincide.
     let (|MultDe3|_|) i = if i % 3 = 0 then Some MultDe3 else None
     let (|MultDe5|_|) i = if i % 5 = 0 then Some MultDe5 else None
 
@@ -447,7 +447,7 @@ module EjemplosDePatronesActivos =
 module EjemploDeAlgoritmo =
 
     // F# tiene una alta relación señal / ruido, lo que permite leer el código
-    // casi como un algoritmo real
+    // casi como un algoritmo real
 
     // ------ Ejemplo: definir una función sumaDeCuadrados ------
     let sumaDeCuadrados n =
@@ -464,7 +464,7 @@ module EjemploDeAlgoritmo =
        // Si la lista está vacía
        | [] ->
             []                              // devolvemos una lista vacía
-       // si la lista no está vacía
+       // si la lista no está vacía
        | primerElemento::otrosElementos ->  // tomamos el primer elemento
             let elementosMasPequenios =     // extraemos los elementos más pequeños
                 otrosElementos              // tomamos el resto
@@ -487,9 +487,9 @@ module EjemploDeAlgoritmo =
 module AsyncExample =
 
     // F# incluye características para ayudar con el código asíncrono
-    // sin conocer la "pirámide del destino"
-    //
-    // El siguiente ejemplo descarga una secuencia de página web en paralelo.
+    // sin conocer la "pirámide del destino"
+    //
+    // El siguiente ejemplo descarga una secuencia de página web en paralelo.
 
     open System.Net
     open System
@@ -531,9 +531,9 @@ module AsyncExample =
 module EjemploCompatibilidadNet =
 
     // F# puede hacer casi cualquier cosa que C# pueda hacer, y se ajusta
-    // perfectamente con bibliotecas .NET o Mono.
+    // perfectamente con bibliotecas .NET o Mono.
 
-    // ------- Trabaja con las funciones de las bibliotecas existentes  -------
+    // ------- Trabaja con las funciones de las bibliotecas existentes  -------
 
     let (i1success,i1) = System.Int32.TryParse("123");
     if i1success then printfn "convertido como %i" i1 else printfn "conversion fallida"
@@ -559,7 +559,7 @@ module EjemploCompatibilidadNet =
     // ------- Código orientado a objetos -------
 
     // F# es también un verdadero lenguaje OO.
-    // Admite clases, herencia, métodos virtuales, etc.
+    // Admite clases, herencia, métodos virtuales, etc.
 
     // interfaz de tipo genérico
     type IEnumerator<'a> =

es/hy.md

@@ -6,162 +6,162 @@ translators:
     - ["Roberto R", "https://github.com/rrodriguze"]
 ---
 
-Hy es un lenguaje de Lisp escrito sobre Python. Esto es posible convirtiendo
-código Hy en un árbol abstracto de Python (ast). Por lo que, esto permite a
-Hy llamar a código Python nativo y viceversa.
+Hy es un lenguaje de Lisp escrito sobre Python. Esto es posible convirtiendo
+código Hy en un árbol abstracto de Python (ast). Por lo que, esto permite a
+Hy llamar a código Python nativo y viceversa.
 
 ```hylang
-;; Esto es una intrucción muy básica a Hy, como la del siguiente enlace
-;; https://hylang.org/try-hy
+;; Esto es una intrucción muy básica a Hy, como la del siguiente enlace
+;; https://hylang.org/try-hy
 ;;
-; Comentarios usando punto y coma, como en otros Lisps
+; Comentarios usando punto y coma, como en otros Lisps
 
-;; Nociones básicas de expresiones
-; Los programas List están hechos de expresiones simbólicas como la siguiente
-(some-function args)
-; ahora el esencial "Hola Mundo"
-(print "hello world")
+;; Nociones básicas de expresiones
+; Los programas List están hechos de expresiones simbólicas como la siguiente
+(some-function args)
+; ahora el esencial "Hola Mundo"
+(print "hello world")
 
-;; Tipos de datos simples
-; Todos los tipos de datos simples son exactamente semejantes a sus homólogos
-; en Python
-42 ; => 42
-3.14 ; => 3.14
-True ; => True
-4+10j ; => (4+10j) un número complejo
+;; Tipos de datos simples
+; Todos los tipos de datos simples son exactamente semejantes a sus homólogos
+; en Python
+42 ; => 42
+3.14 ; => 3.14
+True ; => True
+4+10j ; => (4+10j) un número complejo
 
-; Vamos a comenzar con un poco de arimética simple
-(+ 4 1) ;=> 5
-; el operador es aplicado a todos los argumentos, como en otros Lisps
-(+ 4 1 2 3) ;=> 10
-(- 2 1) ;=> 1
-(* 4 2) ;=> 8
-(/ 4 1) ;=> 4
-(% 4 2) ;=> 0 o operador módulo
-; la exponenciación es representada por el operador ** como Python
-(** 3 2) ;=> 9
-; las funciones anidadas funcionan como lo esperado
-(+ 2 (* 4 2)) ;=> 10
-; también los operadores lógicos igual o no igual se comportan como se espera
-(= 5 4) ;=> False
-(not (= 5 4)) ;=> True
+; Vamos a comenzar con un poco de arimética simple
+(+ 4 1) ;=> 5
+; el operador es aplicado a todos los argumentos, como en otros Lisps
+(+ 4 1 2 3) ;=> 10
+(- 2 1) ;=> 1
+(* 4 2) ;=> 8
+(/ 4 1) ;=> 4
+(% 4 2) ;=> 0 o operador módulo
+; la exponenciación es representada por el operador ** como Python
+(** 3 2) ;=> 9
+; las funciones anidadas funcionan como lo esperado
+(+ 2 (* 4 2)) ;=> 10
+; también los operadores lógicos igual o no igual se comportan como se espera
+(= 5 4) ;=> False
+(not (= 5 4)) ;=> True
 
-;; variables
-; las variables se configuran usando SETV, los nombres de las variables pueden
-; usar utf-8, excepto for ()[]{}",'`;#|
-(setv a 42)
-(setv π 3.14159)
-(def *foo* 42)
-;; otros tipos de datos de almacenamiento
-; strings, lists, tuples & dicts
-; estos son exactamente los mismos tipos de almacenamiento en Python
-"hello world" ;=> "hello world"
-; las operaciones de cadena funcionan de manera similar en Python
-(+ "hello " "world") ;=> "hello world"
-; Las listas se crean usando [], la indexación comienza en 0
-(setv mylist [1 2 3 4])
-; las tuplas son estructuras de datos inmutables
-(setv mytuple (, 1 2))
-; los diccionarios son pares de valor-clave
-(setv dict1 {"key1" 42 "key2" 21})
-; :nombre se puede usar para definir palabras clave en Hy que se pueden usar para claves
-(setv dict2 {:key1 41 :key2 20})
-; usar 'get' para obtener un elemento en un índice/key
-(get mylist 1) ;=> 2
-(get dict1 "key1") ;=> 42
-; Alternativamente, si se usan palabras clave que podrían llamarse directamente
-(:key1 dict2) ;=> 41
+;; variables
+; las variables se configuran usando SETV, los nombres de las variables pueden
+; usar utf-8, excepto for ()[]{}",'`;#|
+(setv a 42)
+(setv π 3.14159)
+(def *foo* 42)
+;; otros tipos de datos de almacenamiento
+; strings, lists, tuples & dicts
+; estos son exactamente los mismos tipos de almacenamiento en Python
+"hello world" ;=> "hello world"
+; las operaciones de cadena funcionan de manera similar en Python
+(+ "hello " "world") ;=> "hello world"
+; Las listas se crean usando [], la indexación comienza en 0
+(setv mylist [1 2 3 4])
+; las tuplas son estructuras de datos inmutables
+(setv mytuple (, 1 2))
+; los diccionarios son pares de valor-clave
+(setv dict1 {"key1" 42 "key2" 21})
+; :nombre se puede usar para definir palabras clave en Hy que se pueden usar para claves
+(setv dict2 {:key1 41 :key2 20})
+; usar 'get' para obtener un elemento en un índice/key
+(get mylist 1) ;=> 2
+(get dict1 "key1") ;=> 42
+; Alternativamente, si se usan palabras clave que podrían llamarse directamente
+(:key1 dict2) ;=> 41
 
-;; funciones y otras estructuras de programa
-; las funciones son definidas usando defn, o el último sexp se devuelve por defecto
-(defn greet [name]
-  "A simple greeting" ; un docstring opcional
-  (print "hello " name))
+;; funciones y otras estructuras de programa
+; las funciones son definidas usando defn, o el último sexp se devuelve por defecto
+(defn greet [name]
+  "A simple greeting" ; un docstring opcional
+  (print "hello " name))
 
-(greet "bilbo") ;=> "hello bilbo"
+(greet "bilbo") ;=> "hello bilbo"
 
-; las funciones pueden tener argumentos opcionales, así como argumentos-clave
-(defn foolists [arg1 &optional [arg2 2]]
-  [arg1 arg2])
+; las funciones pueden tener argumentos opcionales, así como argumentos-clave
+(defn foolists [arg1 &optional [arg2 2]]
+  [arg1 arg2])
 
-(foolists 3) ;=> [3 2]
-(foolists 10 3) ;=> [10 3]
+(foolists 3) ;=> [3 2]
+(foolists 10 3) ;=> [10 3]
 
-; las funciones anonimas son creadas usando constructores 'fn' y 'lambda'
-; que son similares a 'defn'
-(map (fn [x] (* x x)) [1 2 3 4]) ;=> [1 4 9 16]
+; las funciones anonimas son creadas usando constructores 'fn' y 'lambda'
+; que son similares a 'defn'
+(map (fn [x] (* x x)) [1 2 3 4]) ;=> [1 4 9 16]
 
-;; operaciones de secuencia
-; Hy tiene algunas utilidades incluidas para operaciones de secuencia, etc.
-; recuperar el primer elemento usando 'first' o 'car'
-(setv mylist [1 2 3 4])
-(setv mydict {"a" 1 "b" 2})
-(first mylist) ;=> 1
+;; operaciones de secuencia
+; Hy tiene algunas utilidades incluidas para operaciones de secuencia, etc.
+; recuperar el primer elemento usando 'first' o 'car'
+(setv mylist [1 2 3 4])
+(setv mydict {"a" 1 "b" 2})
+(first mylist) ;=> 1
 
-; corte listas usando 'cut'
-(cut mylist 1 3) ;=> [2 3]
+; corte listas usando 'cut'
+(cut mylist 1 3) ;=> [2 3]
 
-; obtener elementos de una lista o dict usando 'get'
-(get mylist 1) ;=> 2
-(get mydict "b") ;=> 2
-; la lista de indexación comienza a partir de 0, igual que en Python
-; assoc puede definir elementos clave/índice
-(assoc mylist 2 10) ; crear mylist [1 2 10 4]
-(assoc mydict "c" 3) ; crear mydict {"a" 1 "b" 2 "c" 3}
-; hay muchas otras funciones que hacen que trabajar con secuencias sea
-; entretenido
+; obtener elementos de una lista o dict usando 'get'
+(get mylist 1) ;=> 2
+(get mydict "b") ;=> 2
+; la lista de indexación comienza a partir de 0, igual que en Python
+; assoc puede definir elementos clave/índice
+(assoc mylist 2 10) ; crear mylist [1 2 10 4]
+(assoc mydict "c" 3) ; crear mydict {"a" 1 "b" 2 "c" 3}
+; hay muchas otras funciones que hacen que trabajar con secuencias sea
+; entretenido
 
-;; Python interop
-;; los import funcionan exactamente como en Python
-(import datetime)
-(import functools [partial reduce]) ; importa fun1 e fun2 del module1
-(import matplotlib.pyplot :as plt) ; haciendo una importación en foo como en bar
-; todos los métodos de Python incluídos etc. son accesibles desde Hy
-; a.foo(arg) is called as (.foo a arg)
-(.split (.strip "hello world  ")) ;=> ["hello" "world"]
+;; Python interop
+;; los import funcionan exactamente como en Python
+(import datetime)
+(import functools [partial reduce]) ; importa fun1 e fun2 del module1
+(import matplotlib.pyplot :as plt) ; haciendo una importación en foo como en bar
+; todos los métodos de Python incluídos etc. son accesibles desde Hy
+; a.foo(arg) is called as (.foo a arg)
+(.split (.strip "hello world  ")) ;=> ["hello" "world"]
 
-;; Condicionales
-; (if condition (body-if-true) (body-if-false)
-(if (= passcode "moria")
-  (print "welcome")
-  (print "Speak friend, and Enter!"))
+;; Condicionales
+; (if condition (body-if-true) (body-if-false)
+(if (= passcode "moria")
+  (print "welcome")
+  (print "Speak friend, and Enter!"))
 
-; anidar múltiples cláusulas 'if else if' con condiciones
+; anidar múltiples cláusulas 'if else if' con condiciones
 (cond
- (= someval 42) (print "Life, universe and everything else!")
- (> someval 42) (print "val too large")
- (< someval 42) (print "val too small"))
+ (= someval 42) (print "Life, universe and everything else!")
+ (> someval 42) (print "val too large")
+ (< someval 42) (print "val too small"))
 
-; declaraciones de grupo con 'do', son ejecutadas secuencialmente
-; formas como defn tienen un 'do' implícito
+; declaraciones de grupo con 'do', son ejecutadas secuencialmente
+; formas como defn tienen un 'do' implícito
 (do
- (setv someval 10)
- (print "someval is set to " someval)) ;=> 10
+ (setv someval 10)
+ (print "someval is set to " someval)) ;=> 10
 
-; crear enlaces léxicos con 'let', todas las variables definidas de esta manera
-; tienen alcance local
-(let [[nemesis {"superman" "lex luther"
-                "sherlock" "moriarty"
-                "seinfeld" "newman"}]]
-  (for [(, h v) (.items nemesis)]
-    (print (.format "{0}'s nemesis was {1}" h v))))
+; crear enlaces léxicos con 'let', todas las variables definidas de esta manera
+; tienen alcance local
+(let [[nemesis {"superman" "lex luther"
+                "sherlock" "moriarty"
+                "seinfeld" "newman"}]]
+  (for [(, h v) (.items nemesis)]
+    (print (.format "{0}'s nemesis was {1}" h v))))
 
-;; clases
-; las clases son definidas de la siguiente manera
+;; clases
+; las clases son definidas de la siguiente manera
 (defclass Wizard [object]
-  (defn __init__ [self spell]
-    (setv self.spell spell))
+  (defn __init__ [self spell]
+    (setv self.spell spell))
 
-  (defn get-spell [self]
-    self.spell))
+  (defn get-spell [self]
+    self.spell))
 ```
 
-### Otras lecturas
+### Otras lecturas
 
-Este tutorial apenas es una introducción básica para Hy/Lisp/Python.
+Este tutorial apenas es una introducción básica para Hy/Lisp/Python.
 
-Docs Hy: [https://hylang.org/hy/doc](https://hylang.org/hy/doc)
+Docs Hy: [https://hylang.org/hy/doc](https://hylang.org/hy/doc)
 
-Repo Hy en GitHub: [https://github.com/hylang/hy](https://github.com/hylang/hy)
+Repo Hy en GitHub: [https://github.com/hylang/hy](https://github.com/hylang/hy)
 
-Acceso a freenode irc con #hy, hashtag en twitter: #hylang
+Acceso a freenode irc con #hy, hashtag en twitter: #hylang

es/kotlin.md

@@ -36,7 +36,7 @@ fun main(args: Array<String>) {
     /*
     En la mayoría de los casos, Kotlin puede determinar cuál es el tipo de una variable,
     de tal manera que no tenemos que especificarlo explícitamente cada vez.
-    Podemos declarar explícitamente el tipo de una variable así:
+    Podemos declarar explícitamente el tipo de una variable así:
     */
     val foo: Int = 7
     
@@ -59,7 +59,7 @@ fun main(args: Array<String>) {
 
     /*
     Una cadena está delimitada por comillas triple (""").
-    Estas cadenas pueden contener saltos de línea y otros caracteres.
+    Estas cadenas pueden contener saltos de línea y otros caracteres.
     */
     val fooRawString = """
     fun helloWorld(val name : String) {
@@ -70,7 +70,7 @@ fun main(args: Array<String>) {
 
     /*
     Las cadenas pueden contener interpolación de cadenas.
-    La interpolación de cadenas comienza con un signo de dólar ($).
+    La interpolación de cadenas comienza con un signo de dólar ($).
     */
     val fooTemplateString = "$fooString tiene ${fooString.length} caracteres"
     println(fooTemplateString)
@@ -78,8 +78,8 @@ fun main(args: Array<String>) {
     /*
     Para que una variable pueda aceptar valor nulo se debe especificar
     explícitamente como anulable añadiendole ? a su tipo.
-    Podemos acceder a una variable anulable mediante el uso del operador ?.
-    Podemos utilizar el operador ?: para especificar un valor alternativo
+    Podemos acceder a una variable anulable mediante el uso del operador ?.
+    Podemos utilizar el operador ?: para especificar un valor alternativo
     a usar si una variable es nula.
     */
     var fooNullable: String? = "abc"

factor.md

@@ -175,6 +175,6 @@ name get-global .       ! "Bob"
 [ 2 + ] \ - suffix                         ! Quotation [ 2 + - ]
 ```
 
-##Ready For More?
+## Further reading
 
 * [Factor Documentation](http://docs.factorcode.org/content/article-help.home.html)

forth.md

@@ -218,7 +218,7 @@ page
 \ bye
 ```
 
-##Ready For More?
+## Further reading
 
 * [Starting Forth](http://www.forth.com/starting-forth/)
 * [Simple Forth](http://www.murphywong.net/hello/simple.htm)

fr/c++.md

@@ -746,8 +746,8 @@ bool faireQuelqueChoseAvecUnFichier(const char* nomDuFichier)
 
     // Suppose que chaque fonction retourne faux si elle échoue
     if (!faireQuelqueChoseAvecLeFichier(fh)) {
-        fclose(fh); // Ferme le flux d'entrée du fichier pour empêcher les fuites
-        return false; // Propage l'erreur
+        fclose(fh); // Ferme le flux d'entrée du fichier pour empêcher les fuites
+        return false; // Propage l'erreur
     }
     if (!faireAutreChoseAvec(fh)) {
         fclose(fh);

fr/livescript.md

@@ -93,7 +93,7 @@ fruits = <[ apple orange pear ]>
 fruits[0]       # => "apple"
 
 # Les objets sont une collection non ordonnées de paires clé/valeur, et 
-# d'autres choses (que nous verrons plus tard).
+# d'autres choses (que nous verrons plus tard).
 person =
   name: "Christina"
   likes:
@@ -101,7 +101,7 @@ person =
     * "and other cute stuff"
 
 # A nouveau, vous pouvez utiliser une expression plus consise à l'aide des 
-# accolades:
+# accolades:
 person = {name: "Christina", likes: ["kittens", "and other cute stuff"]}
 
 # Vous pouvez récupérer une entrée via sa clé:
@@ -113,7 +113,7 @@ person["name"]  # => "Christina"
 trailing-space = /\s$/          # les mots-composés deviennent motscomposés
 
 # A l'exception que vous pouvez pouvez utiliser des expressions sur plusieurs
-# lignes!
+# lignes!
 # (les commentaires et les espaces seront ignorés)
 funRE = //
         function\s+(.+)         # nom
@@ -135,9 +135,9 @@ funRE = //
 
 
 # Les comparaisons sont presque identiques, à l'exception que `==` équivaut au
-# `===` de JS, là où le `==` de JS est `~=` en LiveScript, et `===` active la 
-# comparaison d'objets et de tableaux, ainsi que les comparaisons strictes 
-# (sans conversion de type)
+# `===` de JS, là où le `==` de JS est `~=` en LiveScript, et `===` active la 
+# comparaison d'objets et de tableaux, ainsi que les comparaisons strictes 
+# (sans conversion de type)
 2 == 2          # => true
 2 == "2"        # => false
 2 ~= "2"        # => true
@@ -169,8 +169,8 @@ not false       # => true
 ########################################################################        
 
 # Puisque LiveScript est fonctionnel, vous vous attendez à une bonne prise en 
-# charge des fonctions. En LiveScript, il est encore plus évident que les 
-# fonctions sont de premier ordre:
+# charge des fonctions. En LiveScript, il est encore plus évident que les 
+# fonctions sont de premier ordre:
 add = (left, right) -> left + right
 add 1, 2        # => 3
 
@@ -181,7 +181,7 @@ two!
 
 # LiveScript utilise l'environnement de la fonction, comme JavaScript.
 # A l'inverse de JavaScript, le `=` fonctionne comme un opérateur de 
-# déclaration, et il déclarera toujours la variable située à gauche (sauf si
+# déclaration, et il déclarera toujours la variable située à gauche (sauf si
 # la variable a été déclarée dans l'environnement parent). 
 
 # L'opérateur `:=` est disponible pour réutiliser un nom provenant de 
@@ -189,18 +189,18 @@ two!
 
 
 # Vous pouvez extraire les arguments d'une fonction pour récupérer 
-# rapidement les valeurs qui vous intéressent dans une structure de données 
+# rapidement les valeurs qui vous intéressent dans une structure de données 
 # complexe:
 tail = ([head, ...rest]) -> rest
 tail [1, 2, 3]  # => [2, 3]
 
 # Vous pouvez également transformer les arguments en utilisant les opérateurs
-# binaires et unaires. Définir des arguments par défaut est aussi possible.
+# binaires et unaires. Définir des arguments par défaut est aussi possible.
 foo = (a = 1, b = 2) -> a + b
 foo!    # => 3
 
 # You pouvez utiliser cela pour cloner un argument en particulier pour éviter 
-# les effets secondaires. Par exemple:
+# les effets secondaires. Par exemple:
 copy = (^^target, source) ->
   for k,v of source => target[k] = v
   target
@@ -220,12 +220,12 @@ identity = -> it
 identity 1      # => 1
 
 # Les opérateurs ne sont pas des fonctions en LiveScript, mais vous pouvez 
-# facilement les transformer en fonction:
+# facilement les transformer en fonction:
 divide-by-two = (/ 2)
 [2, 4, 8, 16].map(divide-by-two).reduce (+)
 
 # Comme dans tout bon langage fonctionnel, vous pouvez créer des fonctions 
-# composées d'autres fonctions:
+# composées d'autres fonctions:
 double-minus-one = (- 1) . (* 2)
 
 # En plus de la formule mathématique `f . g`, vous avez les opérateurs `>>`
@@ -235,7 +235,7 @@ double-minus-one = (- 1) << (* 2)
 
 
 # Pour appliquer une valeur à une fonction, vous pouvez utiliser les opérateurs
-# `|>` et `<|`:
+# `|>` et `<|`:
 map = (f, xs) --> xs.map f
 [1 2 3] |> map (* 2)            # => [2 4 6]
 
@@ -248,15 +248,15 @@ reduce = (f, xs, initial) --> xs.reduce f, initial
 [1 2 3] |> reduce (+), _, 0     # => 6
 
 
-# Le tiret bas est également utilisé pour l'application partielle,
-# que vous pouvez utiliser pour toute fonction:
+# Le tiret bas est également utilisé pour l'application partielle,
+# que vous pouvez utiliser pour toute fonction:
 div = (left, right) -> left / right
 div-by-two = div _, 2
 div-by-two 4      # => 2
 
 
 # Pour conclure, LiveScript vous permet d'utiliser les fonctions de rappel.
-# (mais vous devriez essayer des approches plus fonctionnelles, comme 
+# (mais vous devriez essayer des approches plus fonctionnelles, comme 
 # Promises).
 # Un fonction de rappel est une fonction qui est passée en argument à une autre
 # fonction:
@@ -289,7 +289,7 @@ x = switch
   | otherwise             => \object      # `otherwise` et `_` correspondent.
 
 # Le corps des fonctions, les déclarations et les assignements disposent d'un
-# `switch` implicite, donc vous n'avez pas besoin de le réécrire: 
+# `switch` implicite, donc vous n'avez pas besoin de le réécrire: 
 take = (n, [x, ...xs]) -->
     | n == 0 => []
     | _      => [x] ++ take (n - 1), xs
@@ -300,14 +300,14 @@ take = (n, [x, ...xs]) -->
 ########################################################################
 
 # Comme en python, vous allez pouvoir utiliser les listes en compréhension,
-# ce qui permet de générer rapidement et de manière élégante une liste de 
-# valeurs:
+# ce qui permet de générer rapidement et de manière élégante une liste de 
+# valeurs:
 oneToTwenty = [1 to 20]
 evens       = [x for x in oneToTwenty when x % 2 == 0]
 
 # `when` et `unless` peuvent être utilisés comme des filtres.
 
-# Cette technique fonctionne sur les objets de la même manière. Vous allez
+# Cette technique fonctionne sur les objets de la même manière. Vous allez
 # pouvoir générer l'ensemble de paires clé/valeur via la syntaxe suivante:
 copy = { [k, v] for k, v of source }
 
@@ -317,8 +317,8 @@ copy = { [k, v] for k, v of source }
 ########################################################################
 
 # Bien que LiveScript soit un langage fonctionnel, il dispose d'intéressants
-# outils pour la programmation objet. La syntaxe de déclaration d'une classe
-# est héritée de CoffeeScript:
+# outils pour la programmation objet. La syntaxe de déclaration d'une classe
+# est héritée de CoffeeScript:
 class Animal
   (@name, kind) ->
     @kind = kind
@@ -332,7 +332,7 @@ kitten = new Cat 'Mei'
 kitten.purr!      # => "*Mei (a cat) purrs*"
 
 # En plus de l'héritage classique, vous pouvez utiliser autant de mixins
-# que vous voulez pour votre classe. Les mixins sont juste des objets:
+# que vous voulez pour votre classe. Les mixins sont juste des objets:
 Huggable =
   hug: -> @action 'is hugged'
 

fr/racket.md

@@ -416,7 +416,7 @@ m ; => '#hash((b . 2) (a . 1) (c . 3))  <-- no `d'
   (values i (number->string i)))
 ; => '#hash((1 . "1") (2 . "2") (3 . "3"))
 
-;; Il y a plein d'autres fonctions natives pour collecter des données à
+;; Il y a plein d'autres fonctions natives pour collecter des données à
 ;; l'aide de boucles
 (for/sum ([i 10]) (* i i)) ; => 285
 (for/product ([i (in-range 1 11)]) (* i i)) ; => 13168189440000

fr/rust.md

@@ -35,271 +35,271 @@ Bien que Rust soit un langage relativement bas niveau, Rust a quelques concepts
 // Les fonctions
 // `I32` est le type 32 bits entiers signés
 fn add2(x: i32, y: i32) -> i32 {
-    // Retour implicite (pas de point virgule)
-    x + y
+    // Retour implicite (pas de point virgule)
+    x + y
 }
 
 // Fonction principale
 fn main() {
-    // Nombres //
+    // Nombres //
 
-    // Liaison immutable
-    let x: i32 = 1;
+    // Liaison immutable
+    let x: i32 = 1;
 
-    // Suffixes entiers et flottants
-    let y: I32 = 13i32;
-    let f: f64 = 1.3f64;
+    // Suffixes entiers et flottants
+    let y: I32 = 13i32;
+    let f: f64 = 1.3f64;
 
-    // Inférence de type
-    // La plupart du temps, le compilateur Rust peut déduire quel est le type 
+    // Inférence de type
+    // La plupart du temps, le compilateur Rust peut déduire quel est le type 
     // de variable, donc vous n'avez pas à écrire une annotation de type explicite.
-    // Tout au long de ce tutoriel, les types sont explicitement annotées dans
+    // Tout au long de ce tutoriel, les types sont explicitement annotées dans
     // de nombreux endroits, mais seulement à des fins de démonstration.
     // L'inférence de type peut les générer pour vous la plupart du temps.
-    let implicit_x = 1;
-    let implicit_f = 1,3;
+    let implicit_x = 1;
+    let implicit_f = 1,3;
 
-    // Arithmétique
-    let somme = x + y + 13;
+    // Arithmétique
+    let somme = x + y + 13;
 
-    // Variable Mutable
-    let mut mutable = 1;
-    let mutable = 4;
-    let mutable += 2;
+    // Variable Mutable
+    let mut mutable = 1;
+    let mutable = 4;
+    let mutable += 2;
 
-    // Chaînes //
+    // Chaînes //
 
-    // Chaîne littérales
-    let x: &str = "Bonjour tout le monde !";
+    // Chaîne littérales
+    let x: &str = "Bonjour tout le monde !";
 
-    // Affichage
-    println!("{} {}", f, x); // 1.3 Bonjour tout le monde
+    // Affichage
+    println!("{} {}", f, x); // 1.3 Bonjour tout le monde
 
-    // Une `Chaîne` - une chaîne de tas alloué
-    let s: String = "Bonjour tout le monde".to_string();
+    // Une `Chaîne` - une chaîne de tas alloué
+    let s: String = "Bonjour tout le monde".to_string();
 
-    // Un morceau de chaîne - une vue immutable sur une autre chaîne.
-    // C'est essentiellement un pointeur immutable sur une chaîne - ça ne
-    // contient effectivement pas le contenu d'une chaîne, juste un pointeur vers
-    // le début et la fin de la chaîne.
-    let s_slice: &str = &s;
+    // Un morceau de chaîne - une vue immutable sur une autre chaîne.
+    // C'est essentiellement un pointeur immutable sur une chaîne - ça ne
+    // contient effectivement pas le contenu d'une chaîne, juste un pointeur vers
+    // le début et la fin de la chaîne.
+    let s_slice: &str = &s;
 
-    println!("{} {}", s, s_slice); // Bonjour tout le monde Bonjour tout le monde
+    println!("{} {}", s, s_slice); // Bonjour tout le monde Bonjour tout le monde
 
-    // Vecteurs/tableau //
+    // Vecteurs/tableau //
 
-    // Un tableau de taille fixe
-    let four_ints: [i32; 4] = [1, 2, 3, 4];
+    // Un tableau de taille fixe
+    let four_ints: [i32; 4] = [1, 2, 3, 4];
 
-    // Un tableau dynamique(vecteur)
-    let mut vecteur: Vec<i32> = vec![1, 2, 3, 4];
-    vecteur.push(5);
+    // Un tableau dynamique(vecteur)
+    let mut vecteur: Vec<i32> = vec![1, 2, 3, 4];
+    vecteur.push(5);
 
-    // Une tranche - une vue immutable sur un vecteur ou un tableau.
-    // Ceci est un peu comme un morceau de chaîne, mais pour les vecteurs.
-    let tranche: &[i32] = &vecteur;
+    // Une tranche - une vue immutable sur un vecteur ou un tableau.
+    // Ceci est un peu comme un morceau de chaîne, mais pour les vecteurs.
+    let tranche: &[i32] = &vecteur;
 
-    // Utiliser `{:?}` pour afficher quelque chose en mode debug
-    println!("{:?} {:?}", vecteur, tranche); // [1, 2, 3, 4, 5] [1, 2, 3, 4, 5]
+    // Utiliser `{:?}` pour afficher quelque chose en mode debug
+    println!("{:?} {:?}", vecteur, tranche); // [1, 2, 3, 4, 5] [1, 2, 3, 4, 5]
 
-    // Tuples //
+    // Tuples //
 
-    // Un tuple est un ensemble de valeurs qui peuvent être de différents types.
-    let x:(i32, &str, f64) = (1, "bonjour", 3.4);
+    // Un tuple est un ensemble de valeurs qui peuvent être de différents types.
+    let x:(i32, &str, f64) = (1, "bonjour", 3.4);
 
-    // Déstructurer `let`
-    let (a, b, c) = x;
-    println!("{} {} {}", a, b, c); // 1 bonjour 3.4
+    // Déstructurer `let`
+    let (a, b, c) = x;
+    println!("{} {} {}", a, b, c); // 1 bonjour 3.4
 
-    // indexation
-    println!("{}", x.1); // Bonjour
+    // indexation
+    println!("{}", x.1); // Bonjour
 
-    //////////////
-    // 2. Types //
-    //////////////
+    //////////////
+    // 2. Types //
+    //////////////
 
-    // Struct
-    struct Point {
-        x: i32,
-        y: i32,
-    }
+    // Struct
+    struct Point {
+        x: i32,
+        y: i32,
+    }
 
-    let origine: Point = Point { x: 0, y: 0 };
+    let origine: Point = Point { x: 0, y: 0 };
 
-    // Un struct avec des champs sans nom, appelé 'tuple struct'.
-    struct Point2(i32, i32);
+    // Un struct avec des champs sans nom, appelé 'tuple struct'.
+    struct Point2(i32, i32);
 
-    let origine2 = Point2(0, 0);
+    let origine2 = Point2(0, 0);
 
-    // Basic C-like enum
-    enum Direction {
-        Àgauche,
-        Droite,
-        En_Haut,
-        Vers_Le_Bas,
-    }
+    // Basic C-like enum
+    enum Direction {
+        Àgauche,
+        Droite,
+        En_Haut,
+        Vers_Le_Bas,
+    }
 
-    let en_haut = Direction::En_Haut;
+    let en_haut = Direction::En_Haut;
 
-    // Enum avec des champs
-    enum OptionnelI32 {
-        AnI32(I32),
-        Rien,
-    }
+    // Enum avec des champs
+    enum OptionnelI32 {
+        AnI32(I32),
+        Rien,
+    }
 
-    let deux: OptionnelI32 = OptionnelI32::AnI32(2);
-    let rien = OptionnelI32::Rien;
+    let deux: OptionnelI32 = OptionnelI32::AnI32(2);
+    let rien = OptionnelI32::Rien;
 
-    // Generics //
+    // Generics //
 
-    struct Foo<T> { bar: T }
+    struct Foo<T> { bar: T }
 
-    // Ceci est défini dans la bibliothèque standard comme `Option`.
-    enum Optionnel<T> {
-        SomeVal(T),
-        NoVal,
-    }
+    // Ceci est défini dans la bibliothèque standard comme `Option`.
+    enum Optionnel<T> {
+        SomeVal(T),
+        NoVal,
+    }
 
-    // Méthodes //
+    // Méthodes //
 
-    impl<T> Foo<T> {
-        // Méthodes prennent un paramètre explicite `de self`.
-        fn get_bar(self) -> T {
-            self.bar
-        }
-    }
+    impl<T> Foo<T> {
+        // Méthodes prennent un paramètre explicite `de self`.
+        fn get_bar(self) -> T {
+            self.bar
+        }
+    }
 
-    let a_foo = Foo { bar: 1 };
-    println!("{}", a_foo.get_bar()); // 1
+    let a_foo = Foo { bar: 1 };
+    println!("{}", a_foo.get_bar()); // 1
 
-    // Traits (connu sous le nom des interfaces ou des classes de types dans
+    // Traits (connu sous le nom des interfaces ou des classes de types dans
     // d'autres langues).
 
-    trait Frobnicate<T> {
-        fn frobnicate(self) -> Option<T>;
-    }
+    trait Frobnicate<T> {
+        fn frobnicate(self) -> Option<T>;
+    }
 
-    impl<T> Frobnicate<T> for Foo<T> {
-        fn frobnicate(self) -> Option<T> {
-            Some(self.bar)
-        }
-    }
+    impl<T> Frobnicate<T> for Foo<T> {
+        fn frobnicate(self) -> Option<T> {
+            Some(self.bar)
+        }
+    }
 
-    let another_foo = Foo { bar: 1 };
-    println!("{:?}", another_foo.frobnicate()); // Some(1)
+    let another_foo = Foo { bar: 1 };
+    println!("{:?}", another_foo.frobnicate()); // Some(1)
 
-    /////////////////////////
-    // 3. Motif correspondant //
-    /////////////////////////
+    /////////////////////////
+    // 3. Motif correspondant //
+    /////////////////////////
 
-    let foo = OptionnelI32::AnI32(1);
-    match foo {
-        OptionnelI32::AnI32(n) => println!("Il est un i32: {}", n),
-        OptionnelI32::Rien     => println!("Il n'y a rien!"),
-    }
+    let foo = OptionnelI32::AnI32(1);
+    match foo {
+        OptionnelI32::AnI32(n) => println!("Il est un i32: {}", n),
+        OptionnelI32::Rien     => println!("Il n'y a rien!"),
+    }
 
-    // Motif avancé correspondant
-    struct FooBar { x: i32, y: OptionnelI32 }
-    let bar = FooBar { x: 15, y: OptionnelI32::AnI32(32) };
+    // Motif avancé correspondant
+    struct FooBar { x: i32, y: OptionnelI32 }
+    let bar = FooBar { x: 15, y: OptionnelI32::AnI32(32) };
 
-    match bar {
-        FooBar { x: 0, y: OptionnelI32 :: AnI32(0)} =>
-            println!("Les chiffres sont nuls!"),
-        FooBar { x: n, y: OptionnelI32 :: AnI32(m)} if n == m =>
-            println!("Les chiffres sont les mêmes"),
-        FooBar { x: n, y: OptionnelI32 :: AnI32(m)} =>
-            println!("Différents numéros: {} {}", n, m)!,
-        FooBar { x: _, y: OptionnelI32 :: Rien} =>
-            println!("Le deuxième numéro est rien!"),
-    }
+    match bar {
+        FooBar { x: 0, y: OptionnelI32 :: AnI32(0)} =>
+            println!("Les chiffres sont nuls!"),
+        FooBar { x: n, y: OptionnelI32 :: AnI32(m)} if n == m =>
+            println!("Les chiffres sont les mêmes"),
+        FooBar { x: n, y: OptionnelI32 :: AnI32(m)} =>
+            println!("Différents numéros: {} {}", n, m)!,
+        FooBar { x: _, y: OptionnelI32 :: Rien} =>
+            println!("Le deuxième numéro est rien!"),
+    }
 
-    /////////////////////
-    // 4. Flux de contrôle //
-    /////////////////////
+    /////////////////////
+    // 4. Flux de contrôle //
+    /////////////////////
 
-    // `for` boucles / itération
-    let array = [1, 2, 3];
-    for i in array {
-        println!("{}", i);
-    }
+    // `for` boucles / itération
+    let array = [1, 2, 3];
+    for i in array {
+        println!("{}", i);
+    }
 
-    // Ranges
-    for i in 0u32..10 {
-        print!("{}", i);
-    }
-    println!("");
-    // imprime `0 1 2 3 4 5 6 7 8 9`
+    // Ranges
+    for i in 0u32..10 {
+        print!("{}", i);
+    }
+    println!("");
+    // imprime `0 1 2 3 4 5 6 7 8 9`
 
-    // `if`
-    if 1 == 1 {
-        println!("Maths est travaille!");
-    } else {
-        println!("Oh non ...!");
-    }
+    // `if`
+    if 1 == 1 {
+        println!("Maths est travaille!");
+    } else {
+        println!("Oh non ...!");
+    }
 
-    // `if` comme expression
-    let valeur = if true {
-        "bien"
-    } else {
-        "mal"
-    };
+    // `if` comme expression
+    let valeur = if true {
+        "bien"
+    } else {
+        "mal"
+    };
 
-    // `while` boucle
-    while 1 == 1 {
-        println!("L'univers fonctionne normalement.");
-    }
+    // `while` boucle
+    while 1 == 1 {
+        println!("L'univers fonctionne normalement.");
+    }
 
-    // Boucle infinie
-    loop {
-        println!("Bonjour!");
-    }
+    // Boucle infinie
+    loop {
+        println!("Bonjour!");
+    }
 
-    /////////////////////////////////
-    // 5. Sécurité & pointeurs mémoire //
-    /////////////////////////////////
+    /////////////////////////////////
+    // 5. Sécurité & pointeurs mémoire //
+    /////////////////////////////////
 
     // Pointeur occasion - une seule chose peut "posséder" pointeur à un moment.
-    // Cela signifie que lorsque le `Box` laisse son champ d'application, il
+    // Cela signifie que lorsque le `Box` laisse son champ d'application, il
     // peut être automatiquement libérée en toute sécurité.
-    let mut mine: Box<i32> = Box::new(3);
-    *mine = 5; // déréférencer
-    // Ici, `now_its_mine` prend possession de `mine`. En d'autres termes,
+    let mut mine: Box<i32> = Box::new(3);
+    *mine = 5; // déréférencer
+    // Ici, `now_its_mine` prend possession de `mine`. En d'autres termes,
     // `mine` est déplacé.
-    let mut now_its_mine = mine;
-    *now_its_mine += 2;
+    let mut now_its_mine = mine;
+    *now_its_mine += 2;
 
-    println!("{}", now_its_mine); // 7
-    // println!("{}", now_its_mine); // Cela ne compile pas parce
+    println!("{}", now_its_mine); // 7
+    // println!("{}", now_its_mine); // Cela ne compile pas parce
     // que `now_its_mine` possède maintenant le pointeur
 
-    // Référence - un pointeur immutable qui fait référence à d'autres données.
-    // Quand une référence est prise à une valeur, nous disons que la valeur
+    // Référence - un pointeur immutable qui fait référence à d'autres données.
+    // Quand une référence est prise à une valeur, nous disons que la valeur
     // a été "emprunté".
-    // Même si une valeur est emprunté immutablement, il ne peut pas être
+    // Même si une valeur est emprunté immutablement, il ne peut pas être
     // muté ou déplacé.
-    // Un emprunt dure jusqu'à la fin de la portée, il a été créé.
-    let mut var = 4;
-    var = 3;
-    let ref_var: &i32 = &var;
+    // Un emprunt dure jusqu'à la fin de la portée, il a été créé.
+    let mut var = 4;
+    var = 3;
+    let ref_var: &i32 = &var;
 
-    println!("{}", var); // Contrairement à `mine`, `var` peut encore être utilisé
-    println!("{}", *ref_var);
-    // Var = 5; // Cela ne compile pas parce que `var` est emprunté.
-    // *ref_var = 6; // Ce ne serait pas correct non plus, parce que `ref_var` est une
+    println!("{}", var); // Contrairement à `mine`, `var` peut encore être utilisé
+    println!("{}", *ref_var);
+    // Var = 5; // Cela ne compile pas parce que `var` est emprunté.
+    // *ref_var = 6; // Ce ne serait pas correct non plus, parce que `ref_var` est une
     // référence immutable.
 
-    // Référence Mutable
-    // Même si une valeur est empruntée de façon mutable, elle ne peut pas être
+    // Référence Mutable
+    // Même si une valeur est empruntée de façon mutable, elle ne peut pas être
     // accessible à tous.
-    let mut var2 = 4;
-    let ref_var2: &mut i32 = &mut var2;
+    let mut var2 = 4;
+    let ref_var2: &mut i32 = &mut var2;
     // '*' est utilisé pour pointer vers le var2 mutably emprunté.
     *ref_var2 += 2;
 
     println!("{}", * ref_var2); // 6, // var2 ne compilerait pas.
-    // ref_var2 est de type &mut i32 donc stocke la référence à i32,
+    // ref_var2 est de type &mut i32 donc stocke la référence à i32,
     // pas la valeur.
-    // var2 = 2; // Cela ne compile pas parce que `var2` est emprunté.
+    // var2 = 2; // Cela ne compile pas parce que `var2` est emprunté.
 }
 ```
 

fr/xml.md

@@ -41,10 +41,10 @@ Contrairement à HTML, XML ne spécifie pas comment afficher ou formater les inf
   Il commence par une déclaration, qui informe certaines métadonnées (en option).
 
 XML utilise une structure arborescente. Ci-dessus, le nœud racine est «librairie», qui a 
-   trois nœuds enfants, qui sont appelés «livres». Ces nœuds ont plus de nœuds enfants, et ainsi de suite ...
+   trois nœuds enfants, qui sont appelés «livres». Ces nœuds ont plus de nœuds enfants, et ainsi de suite ...
 
 On crée les nœuds avec des balises d'ouverture / fermeture, et les enfants sont les nœuds juste entre 
-   les balises d'ouverture et de fermeture. -->
+   les balises d'ouverture et de fermeture. -->
 
 
 <!-- XML porte deux types d'informations:
@@ -72,7 +72,7 @@ Avec cet outil, vous pouvez vérifier les données XML en dehors de la logique d
 
 ```xml
 <!-- Ci-dessous, vous pouvez voir une version simplifiée du document de librairie, 
-   avec l'addition de définition DTD. -->
+   avec l'addition de définition DTD. -->
 
 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE note SYSTEM "Librairie.dtd">
@@ -95,10 +95,10 @@ Avec cet outil, vous pouvez vérifier les données XML en dehors de la logique d
 ]>
 
 <!-- La DTD commence par une déclaration.
-   Après, le nœud racine est déclaré, qui exige un ou plusieurs nœuds enfants. 
-   Chaque «livre» doit contenir exactement un «titre» et «prix» et un attribut 
-   appelé «catégorie», avec «littérature» comme valeur par défaut. 
-   Les nœuds de «titre» et «prix» contiennent des informations de caractère analysés
+   Après, le nœud racine est déclaré, qui exige un ou plusieurs nœuds enfants. 
+   Chaque «livre» doit contenir exactement un «titre» et «prix» et un attribut 
+   appelé «catégorie», avec «littérature» comme valeur par défaut. 
+   Les nœuds de «titre» et «prix» contiennent des informations de caractère analysés
    (Anglais: «parsed character data») -->
 
 <!-- La DTD pourrait être déclarée dans le fichier XML lui-même -->

he/html.md

@@ -151,12 +151,6 @@ HTML קיצור של Hypertext Markup Language כלומר זוהי שפה שמש
 </table>
 ```
 
-## שימוש
-
-HTML נכתב בקבצים המסתיימים ב-`.html` או `.htm`.
-
-**HTML אינה שפת תכנות**
-
 ## לקריאה נוספת
 
 - [Wikipedia](https://he.wikipedia.org/wiki/HTML)

hi/c++.md

@@ -1049,7 +1049,7 @@ for(auto elem: arr) {
 // मजेदार चीजें
 /////////////////////
 
-// सी ++ के पहलू जो नवागंतुकों (और यहां तक ​​​​कि कुछ दिग्गजों) के लिए आश्चर्यजनक हो सकते हैं।
+// सी ++ के पहलू जो नवागंतुकों (और यहां तक कि कुछ दिग्गजों) के लिए आश्चर्यजनक हो सकते हैं।
 // यह खंड, दुर्भाग्य से, बेतहाशा अधूरा है; सी ++ सबसे आसान में से एक है
 // भाषाएं जिनके साथ अपने आप को पैर में गोली मारनी है।
 

hi/d.md

@@ -107,7 +107,7 @@ T max(T)(T a, T b) {
     return a;
 }
 
-// संदर्भ द्वारा पारित सुनिश्चित करने के लिए रेफरी कीवर्ड का प्रयोग करें । यही कारण है कि यहां तक ​​कि 'A' और 'B' , तो है
+// संदर्भ द्वारा पारित सुनिश्चित करने के लिए रेफरी कीवर्ड का प्रयोग करें । यही कारण है कि यहां तक कि 'A' और 'B' , तो है
 //मान प्रकार वे हमेशा ' swap()' के संदर्भ द्वारा पारित हो जाएगा  हैं ।
 void swap(T)(ref T a, ref T b) {
     auto temp = a;

id/smallbasic.md

@@ -28,7 +28,7 @@ print "halo"
 
 REM Struktur kontrol
 FOR index = 0 TO 10 STEP 2
-  ? "Ini adalah nomor baris"; indeks
+  ? "Ini adalah nomor baris"; indeks
 NEXT
 J=0
 REPEAT
@@ -57,10 +57,10 @@ End Try
 
 REM Fungsi dan subrutin buatan pengguna
 func add2(x, y)
-  'Variabel dapat dinyatakan sebagai lokal dalam lingkup/scope dari SUB atau FUNC
-  local k
-  k = "k akan lenyap ketika FUNC ini mengembalikan nilai"
-  add2 = x + y
+  'Variabel dapat dinyatakan sebagai lokal dalam lingkup/scope dari SUB atau FUNC
+  local k
+  k = "k akan lenyap ketika FUNC ini mengembalikan nilai"
+  add2 = x + y
 akhir
 Print add2(5,5)
 sub cetak_ini(ini)

id/xml.md

@@ -95,23 +95,23 @@ Pengurai XML dirancang menjadi sangat ketat, dan akan berhenti melakukan pengura
 </tokobuku>
 
 <!-- Di atas adalah contoh file XML biasa.
-   Dimulai dengan deklarasi, menginformasikan beberapa metadata (opsional).
-  
-   XML menggunakan struktur pohon. Di atas, simpul akar adalah 'tokobuku',
+   Dimulai dengan deklarasi, menginformasikan beberapa metadata (opsional).
+  
+   XML menggunakan struktur pohon. Di atas, simpul akar adalah 'tokobuku',
    yang memiliki tiga node anak, para 'buku'. Node-node tersebut dapat memiliki
    node-node anak, dan seterusnya ...
-  
-   Node dibuat menggunakan tag buka/tutup, dan node-node anak hanya
+  
+   Node dibuat menggunakan tag buka/tutup, dan node-node anak hanya
    berada di antara tag buka dan tutup .-->
 
 
 <!-- XML membawa dua jenis data:
-   1 - Atribut -> Itu metadata tentang sebuah node.
-       Biasanya, parser XML menggunakan informasi ini untuk menyimpan data dengan
+   1 - Atribut -> Itu metadata tentang sebuah node.
+       Biasanya, parser XML menggunakan informasi ini untuk menyimpan data dengan
        benar. Hal ini ditandai dengan muncul dengan format nama = "nilai" dalam pembukaan tag.
-   2 - Elemen -> Itu data yang murni.
-       Itulah yang parser akan mengambil dari file XML.
-       Elemen muncul antara tag membuka dan menutup.-->
+   2 - Elemen -> Itu data yang murni.
+       Itulah yang parser akan mengambil dari file XML.
+       Elemen muncul antara tag membuka dan menutup.-->
       
   
 <!-- Di bawah ini, unsur dengan dua atribut-->
@@ -131,7 +131,7 @@ Dengan alat ini, Anda dapat memeriksa data XML di luar logika aplikasi.
 
 ```xml
 <!-- Di bawah, Anda dapat melihat versi sederhana dari dokumen tokobuku,
-  dengan penambahan definisi DTD .-->
+  dengan penambahan definisi DTD .-->
 
 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE catatan SYSTEM "tokobuku.dtd">
@@ -155,10 +155,10 @@ Dengan alat ini, Anda dapat memeriksa data XML di luar logika aplikasi.
 
 
 <!-- DTD dimulai dengan deklarasi.
-  Berikut, node akar dinyatakan, membutuhkan 1 atau lebih anak node 'buku'.
-  Setiap 'buku' harus berisi tepat satu 'judul' dan 'harga' dan atribut
-  disebut 'kategori', dengan "Sastra" sebagai nilai default.
-  Node yang 'judul' dan 'harga' mengandung karakter data diurai .-->
+  Berikut, node akar dinyatakan, membutuhkan 1 atau lebih anak node 'buku'.
+  Setiap 'buku' harus berisi tepat satu 'judul' dan 'harga' dan atribut
+  disebut 'kategori', dengan "Sastra" sebagai nilai default.
+  Node yang 'judul' dan 'harga' mengandung karakter data diurai .-->
 
 <!-- DTD dapat dideklarasikan di dalam file XML itu sendiri .-->
 

it/rst.md

@@ -57,13 +57,13 @@ Le liste sono semplici come in Markdown:
 
 - primo articolo
 - Secondo elemento
-     - Sottoelemento
+     - Sottoelemento
 
 oppure
 
 * Primo elemento
 * Secondo elemento
-     * Sottoelemento
+     * Sottoelemento
 
 Le tabelle sono molto semplici da inserire:
 

julia.md

@@ -94,8 +94,8 @@ false
 'a'
 
 # Strings are UTF8 encoded, so strings like "π" or "☃" are not directly equivalent
-# to an array of single characters.
-# Only if they contain only ASCII characters can they be safely indexed.
+# to an array of single characters.
+# Only if they contain only ASCII characters can they be safely indexed.
 ascii("This is a string")[1]    # => 'T'
 # => 'T': ASCII/Unicode U+0054 (category Lu: Letter, uppercase)
 # Beware, Julia indexes everything from 1 (like MATLAB), not 0 (like most languages).
@@ -114,7 +114,7 @@ ascii("This is a string")[1]    # => 'T'
 println("I'm Julia. Nice to meet you!")  # => I'm Julia. Nice to meet you!
 
 # Another way to format strings is the printf macro from the stdlib Printf.
-using Printf   # this is how you load (or import) a module
+using Printf   # this is how you load (or import) a module
 @printf "%d is less than %f\n" 4.5 5.3   # => 5 is less than 5.300000
 
 
@@ -392,7 +392,7 @@ end
 for animal = ["dog", "cat", "mouse"]
     println("$animal is a mammal")
     # You can use $ to interpolate variables or expression into strings.
-    # In this special case, no need for parenthesis: $animal and $(animal) give the same
+    # In this special case, no need for parenthesis: $animal and $(animal) give the same
 end
 # => dog is a mammal
 # => cat is a mammal

latex.md

@@ -202,7 +202,7 @@ We can also insert Tables in the same way as figures.
   % the {} arguments below describe how each row of the table is drawn.
   % The basics are simple: one letter for each column, to control alignment:
   % basic options are: c, l, r and p for centered, left, right and paragraph
-  % optionally, you can add a | for a vertical line
+  % optionally, you can add a | for a vertical line
   % See https://en.wikibooks.org/wiki/LaTeX/Tables for more details
   \begin{tabular}{c|cc}  % here it means "centered | vertical line, centered centered"
     Number &  First Name & Last Name \\ % Column rows are separated by &

linker.md

@@ -1,34 +1,31 @@
 ---
 category: tool
-name: GNU linker (ld)
+name: Linker script
 contributors:
     - ["Alexander Kovalchuk", "https://github.com/Zamuhrishka"]
 translators:
     - ["Anuj Shah", "https://github.com/ShahAnuj2610"]
+filename: learn.ld
 ---
 
-## Basic concepts and definitions
-
 **Position counter** - the linker has a special variable
-"." (dot) always contains the current output position.
+"`.`" (dot) always contains the current output position.
 
-## Functions
-
-**ADDR (section)** - returns the absolute address of the specified section. However
+`ADDR (section)` - returns the absolute address of the specified section. However
 this section must be defined before using the ADDR function.
 
-**ALIGN (exp)** - returns the value of the position counter aligned to the border
+`ALIGN (exp)` - returns the value of the position counter aligned to the border
 following the exp expression.
 
-**SIZEOF (section)** - returns the size of the section in bytes.
+`SIZEOF (section)` - returns the size of the section in bytes.
 
-**FILL (param)** - defines the fill pattern for the current section. All
+`FILL (param)` - defines the fill pattern for the current section. All
 other unspecified regions within the section are filled with the value indicated
 in function argument.
 
-**KEEP (param)** - used to mark param as fatal.
+`KEEP (param)` - used to mark param as fatal.
 
-**ENTRY (func)** - defines the function that will be the entry point
+`ENTRY (func)` - defines the function that will be the entry point
 into the program.
 
 ```bash
@@ -81,7 +78,7 @@ SECTIONS
     # Align the current position to the border of 4 bytes.
     . = ALIGN(4);
 
-	# The expression "> MEMORY AREA" indicates which area of ​​memory will be placed
+    # The expression "> MEMORY AREA" indicates which area of memory will be placed
     # this section. In our section, the .isr_vector section will be located in FLASH memory.
   } >FLASH
 
@@ -159,7 +156,7 @@ SECTIONS
     _edata = .;
 
     # AT function indicates that this sector is stored in one memory area
-	# (in our case, FLASH), and it will be executed from another area of ​​memory (in our case, RAM).
+    # (in our case, FLASH), and it will be executed from another area of memory (in our case, RAM).
     # There are two types of addresses:
     # * VMA (Virtual memory address) - this is the run-time address at which the compiler expects
     # see data.

lint/frontmatter.py

@@ -19,7 +19,7 @@ def extract_yaml_frontmatter(file_path):
 
 yaml_config = yamllint.config.YamlLintConfig(
     """{
-        extends: relaxed, 
+        extends: default,
         rules: {
             commas: disable,
             trailing-spaces: disable,

mips.md

@@ -244,7 +244,7 @@ gateways and routers.
 ## FUNCTIONS ##
   _functions:
     # Functions are callable procedures that can accept arguments and return 
-    # values all denoted with labels, like above
+    # values all denoted with labels, like above
 
     main:                                 # Programs begin with main func
       jal return_1                        # jal will store the current PC in $ra

pl/java.md

@@ -119,7 +119,7 @@ public class LearnJava {
 
         // Zmienną inicjalizuje się poprzez <rodzaj> <nazwa> = <wartość>
         int barInt = 1;
-        // Możliwe jest zainicjalizowanie wielu zmiennych tego samego typu tą samą wartością
+        // Możliwe jest zainicjalizowanie wielu zmiennych tego samego typu tą samą wartością
         // rodzaj <nazwa1>, <nazwa2>, <nazwa3>
         // <nazwa1> = <nazwa2> = <nazwa3> = <wartość>
         int barInt1, barInt2, barInt3;

prolog.md

@@ -334,6 +334,6 @@ safe(Group) :- memberchk(joker, Group) -> memberchk(batman, Group) ; true.
 ?- maplist(plus(1), [2,3,4], Output).   % Output = [3, 4, 5].
 ```
 
-##Ready For More?
+## Further reading
 
 * [SWI-Prolog](http://www.swi-prolog.org/)

pt-br/csharp.md

@@ -106,7 +106,7 @@ namespace Learning.CSharp
             char fooChar = 'A';
 
             // Strings - ao contrário dos anteriores tipos base, que são todos os tipos de valor,
-            // Uma string é um tipo de referência. Ou seja, você pode configurá-lo como nulo
+            // Uma string é um tipo de referência. Ou seja, você pode configurá-lo como nulo
             string fooString = "\"escape\" quotes and add \n (new lines) and \t (tabs)";
             Console.WriteLine(fooString);
 
@@ -732,9 +732,9 @@ on a new line! ""Wow!"", the masses cried";
         }
 
         // Você também pode definir uma propriedade automática em uma linha
-        // Esta sintaxe criará um campo de apoio automaticamente.
-        // Você pode definir um modificador de acesso no getter ou no setter (ou ambos)
-        // para restringir seu acesso:
+        // Esta sintaxe criará um campo de apoio automaticamente.
+        // Você pode definir um modificador de acesso no getter ou no setter (ou ambos)
+        // para restringir seu acesso:
         public bool IsBroken { get; private set; }
 
         // Properties can be auto-implemented
@@ -856,7 +856,7 @@ on a new line! ""Wow!"", the masses cried";
 
     /// <summary>
     /// Exemplo de como conectar-se ao DB via LinqToSql.
-    /// EntityFramework First Code é impressionante (semelhante ao ActiveRecord de Ruby, mas bidirecional)
+    /// EntityFramework First Code é impressionante (semelhante ao ActiveRecord de Ruby, mas bidirecional)
     /// http://msdn.microsoft.com/en-us/data/jj193542.aspx
     /// </summary>
     public class BikeRepository : DbContext

pt-br/cypher.md

@@ -71,7 +71,7 @@ Você pode encadear vários relacionamentos. Este path descreve o amigo de um am
 `(a:Person)-[:MANAGES]->(b:Person)-[:MANAGES]->(c:Person)`
 Uma encadeamento também pode ser direcionada. Este path descreve que **a** é o chefe de **b** e o grande chefe de **c**.
 
-Padrões frequentemente usados ​​(do Neo4j doc):
+Padrões frequentemente usados (do Neo4j doc):
 
 ```cypher
 // Amigo de um amigo

pt-br/factor.md

@@ -125,14 +125,14 @@ f [ . ] when*      ! Nenhuma saída, pilha vazia, f é consumida porque é falsa
 
 ! Variáveis
 ! Normalmente, espera-se que os programas Factor mantenham todos os dados na pilha.
-! Usar variáveis ​​nomeadas torna a refatoração mais difícil (e é chamada de Factor por um motivo)
-! Variáveis ​​globais, se você precisar:
+! Usar variáveis nomeadas torna a refatoração mais difícil (e é chamada de Factor por um motivo)
+! Variáveis globais, se você precisar:
 
 SYMBOL: name            ! Cria o nome como uma palavra identificadora
 "Bob" name set-global   ! Sem saída
 name get-global .       ! "Bob"
 
-! Variáveis ​​locais nomeadas são consideradas uma extensão, mas estão disponíveis
+! Variáveis locais nomeadas são consideradas uma extensão, mas estão disponíveis
 ! Em uma citação ..
 [| m n                  ! A citação captura os dois principais valores da pilha em m e n
  | m n + ]              ! Leia-os
@@ -143,10 +143,10 @@ name get-global .       ! "Bob"
    c . ;                  ! Imprima isso
 
 ! Em uma palavra declarada dessa maneira, o lado de entrada da declaração de pilha
-! torna-se significativo e fornece os valores das variáveis ​​em que os valores da pilha são capturados
+! torna-se significativo e fornece os valores das variáveis em que os valores da pilha são capturados
 :: double ( a -- result ) a 2 * ;
 
-! Variáveis ​​são declaradas mutáveis ​​ao terminar seu nome com um ponto de exclamação
+! Variáveis são declaradas mutáveis ao terminar seu nome com um ponto de exclamação
 :: mword2 ( a! -- x y )   ! Capture o topo da pilha na variável mutável a
    a                      ! Empurrar a
    a 2 * a!               ! Multiplique por 2 e armazene o resultado em a

pt-br/java.md

@@ -413,7 +413,7 @@ class Velocipede extends Bicicleta {
 // Exemplo - Comida:
 public interface Comestivel {
     public void comer(); // Qualquer classe que implementa essa interface, deve
-                         // implementar este método.
+                         // implementar este método.
 }
 
 public interface Digestivel {
@@ -483,8 +483,8 @@ public abstract class Animal
     }
 
     // Não há necessidade de inicializar, no entanto, em uma interface
-    // a variável é implicitamente final e, portanto, tem
-    // de ser inicializada.
+    // a variável é implicitamente final e, portanto, tem
+    // de ser inicializada.
     protected int idade;
 
     public void mostrarIdade()
@@ -503,7 +503,7 @@ class Cachorro extends Animal
 {
 
     // Nota: ainda precisamos substituir os métodos abstratos na
-    // classe abstrata.
+    // classe abstrata.
     @Override
     public void fazerSom()
     {
@@ -512,10 +512,10 @@ class Cachorro extends Animal
     }
 
     // NOTA: Você receberá um erro se usou a
-    // anotação Override aqui, uma vez que java não permite
-    // sobrescrita de métodos estáticos.
-    // O que está acontecendo aqui é chamado de "esconder o método".
-    // Vejá também este impressionante SO post: http://stackoverflow.com/questions/16313649/
+    // anotação Override aqui, uma vez que java não permite
+    // sobrescrita de métodos estáticos.
+    // O que está acontecendo aqui é chamado de "esconder o método".
+    // Vejá também este impressionante SO post: http://stackoverflow.com/questions/16313649/
     public static void main(String[] args)
     {
         Cachorro pluto = new Cachorro();
@@ -540,7 +540,7 @@ class Cachorro extends Animal
 public final class TigreDenteDeSabre extends Animal
 {
     // Nota: Ainda precisamos substituir os métodos abstratos na
-    // classe abstrata.
+    // classe abstrata.
     @Override
     public void fazerSom();
     {
@@ -555,7 +555,7 @@ public abstract class Mamifero()
     // <modificador-de-acesso> final <tipo-de-retorno> <nome-do-método>(<argumentos>)
 
     // Métodos finais, como classes finais, não podem ser substituídos por uma classe filha,
-    // e são, portanto, a implementação final do método.
+    // e são, portanto, a implementação final do método.
     public final boolean EImpulsivo()
     {
         return true;

pt-br/less.md

@@ -26,7 +26,7 @@ Less (e outros pré-processadores, como o [Sass](http://sass-lang.com/)) ajudam
 @secondary-color: #51527f;
 @body-font: 'Roboto', sans-serif;
 
-/* Você pode usar as variáveis ​​em toda a sua folha de estilo.
+/* Você pode usar as variáveis em toda a sua folha de estilo.
    Agora, se você quiser alterar uma cor, só precisa fazer a alteração uma vez. */
 
 body {

pt-br/make.md

@@ -31,7 +31,7 @@ Existem muitas variedades de make na existência, no entanto, este artigo pressu
 # Uma regra - esta regra só será executada se o arquivo0.txt não existir.
 arquivo0.txt:
 	echo "foo" > arquivo0.txt
-	# Mesmo os comentários nestas seções da 'receita' são passados ​​para o shell.
+	# Mesmo os comentários nestas seções da 'receita' são passados para o shell.
 	# Experimentar `make arquivo0.txt` or simplyou simplesmente `make` - primeira regra é o padrão.
 
 # Esta regra só será executada se arquivo0.txt for mais recente que arquivo1.txt.
@@ -74,7 +74,7 @@ ex0.txt ex1.txt: maker
 # Alvos falsos comuns são: todos fazem instalação limpa ...
 
 #-----------------------------------------------------------------------
-# Variáveis ​​Automáticas e Curingas
+# Variáveis Automáticas e Curingas
 #-----------------------------------------------------------------------
 
 process: Arquivo*.txt	# Usando um curinga para corresponder nomes de arquivos
@@ -130,7 +130,7 @@ small/%.png: %.svg
 #-----------------------------------------------------------------------
 # aka. macros
 
-# As variáveis ​​são basicamente todos os tipos de string
+# As variáveis são basicamente todos os tipos de string
 
 name = Ted
 name2="Sarah"
@@ -139,14 +139,14 @@ echo:
 	@echo $(name)
 	@echo ${name2}
 	@echo $name    # Isso não funcionará, tratado como $ (n)ame.
-	@echo $(name3) # Variáveis ​​desconhecidas são tratadas como strings vazias.
+	@echo $(name3) # Variáveis desconhecidas são tratadas como strings vazias.
 
 # Existem 4 lugares para definir variáveis.
 # Em ordem de prioridade, do maior para o menor:
 # 1: argumentos de linha de comando
 # 2: Makefile
-# 3: variáveis ​​de ambiente do shell - faça importações automaticamente.
-# 4: make tem algumas variáveis ​​predefinidas
+# 3: variáveis de ambiente do shell - faça importações automaticamente.
+# 4: make tem algumas variáveis predefinidas
 
 name4 ?= Jean
 # Somente defina a variável se a variável de ambiente ainda não estiver definida.
@@ -157,12 +157,12 @@ override name5 = David
 name4 +=grey
 # Anexar valores à variável (inclui um espaço).
 
-# Valores variáveis ​​específicos de padrões (extensão GNU).
+# Valores variáveis específicos de padrões (extensão GNU).
 echo: name2 = Sara # Verdadeiro dentro da regra de correspondência
 	# e também dentro de suas recursivas dependências
 	# (exceto que ele pode quebrar quando seu gráfico ficar muito complicado!)
 
-# Algumas variáveis ​​definidas automaticamente pelo make
+# Algumas variáveis definidas automaticamente pelo make
 echo_inbuilt:
 	echo $(CC)
 	echo ${CXX}
@@ -177,7 +177,7 @@ echo_inbuilt:
 # Variáveis 2
 #-----------------------------------------------------------------------
 
-# O primeiro tipo de variáveis ​​é avaliado a cada vez que elas são usadas.
+# O primeiro tipo de variáveis é avaliado a cada vez que elas são usadas.
 # TIsso pode ser caro, então existe um segundo tipo de variável que é
 # avaliado apenas uma vez. (Esta é uma extensão do GNU make)
 
@@ -185,7 +185,7 @@ var := hello
 var2 ::=  $(var) hello
 #:= e ::= são equivalentes.
 
-# Essas variáveis ​​são avaliadas procedimentalmente (na ordem em que
+# Essas variáveis são avaliadas procedimentalmente (na ordem em que
 # aparecem), quebrando assim o resto da línguagem!
 
 # Isso não funciona

pt-br/processing.md

@@ -100,7 +100,7 @@ double valorDouble = 1,12345D; // Double (números de ponto flutuante de 64 bits
 
 // Existem vários tipos de dados compostos que estão disponíveis por padrão para 
 // uso no Processing.
-// Primeiramente, farei um resumo dos mais usados ​​para economizar tempo.
+// Primeiramente, farei um resumo dos mais usados para economizar tempo.
 
 // String
 // Enquanto o tipo de dados char usa '', o tipo de dados String usa "" - aspas 
@@ -118,7 +118,7 @@ print("Olá " + "Mundo!"); // Olá Mundo!
 // próprios objetos. Como os arrays são semelhantes aos objetos, eles devem 
 // ser criados com a palavra-chave "new".
 int[] arrayInt = new int[5];
-int[] arrayIntComValores ​​= {1, 2, 3}; // Você também pode preencher com dados.
+int[] arrayIntComValores = {1, 2, 3}; // Você também pode preencher com dados.
 
 // Lista de Arrays
 // As funções são semelhantes às do array; arraylists podem conter qualquer 
@@ -192,7 +192,7 @@ if (author.getAppearance().equals("quente")) {
   // Você pode verificar outras condições aqui.
   print("Algo está realmente errado aqui!");
 }
-// Um ​​atalho para instruções if-else também pode ser usado.
+// Um atalho para instruções if-else também pode ser usado.
 int = 3;
 String valor = (i > 5) ? "Grande" : "Pequena"; // "Pequena"
 

pt-br/sass.md

@@ -131,10 +131,10 @@ div {
 
 
 /* Sass fornece funções que podem ser utilizados para realizar uma variedade de
-    tarefas. Considere o seguinte */
+    tarefas. Considere o seguinte */
 
 /* Funções pode ser chamado usando seu nome e passando o
-    argumentos necessários */
+    argumentos necessários */
     
 body {
   width: round(10.25px);
@@ -162,7 +162,7 @@ body {
    reutilizável. */
 
 /* Esta função terá um tamanho de destino e o tamanho do pai (parent), calcular
-   e voltar a percentagem */
+   e voltar a percentagem */
 
 @function calculate-percentage($target-size, $parent-size) {
   @return $target-size / $parent-size * 100%;
@@ -219,11 +219,11 @@ $main-content: calculate-percentage(600px, 960px);
 }
 
 /* Ao ampliar uma declaração CSS é preferível a criação de um mixin,
-   por causa da maneira em que agrupa as classes com todos que compartilham
-   o mesmo estilo base. Se isso for feito com um mixin, a largura,
-   altura, e a borda seria duplicado para cada instrução que
-   o chamado mixin. Enquanto isso não irá afetar o seu fluxo de trabalho, será
-   adicionado inchaço desnecessário para os arquivos criados pelo compilador Sass. */
+   por causa da maneira em que agrupa as classes com todos que compartilham
+   o mesmo estilo base. Se isso for feito com um mixin, a largura,
+   altura, e a borda seria duplicado para cada instrução que
+   o chamado mixin. Enquanto isso não irá afetar o seu fluxo de trabalho, será
+   adicionado inchaço desnecessário para os arquivos criados pelo compilador Sass. */
 
 
 
@@ -293,8 +293,8 @@ ul li a {
 
 
 /* Sass permite criar arquivos parciais. Isso pode ajudar a manter seu Sass
-   código modularizado. Arquivos parciais deve começar com um '_', por exemplo, _reset.css.
-   Parciais não são geradas em CSS. */
+   código modularizado. Arquivos parciais deve começar com um '_', por exemplo, _reset.css.
+   Parciais não são geradas em CSS. */
 
 
 
@@ -309,9 +309,9 @@ ol {
 }
 
 /* Sass oferece @import que pode ser usado para importar parciais em um arquivo.
-   Isso difere da declaração CSS @import tradicional, que faz
-   outra solicitação HTTP para buscar o arquivo importado. Sass converte os
-   arquivo importados e combina com o código compilado. */
+   Isso difere da declaração CSS @import tradicional, que faz
+   outra solicitação HTTP para buscar o arquivo importado. Sass converte os
+   arquivo importados e combina com o código compilado. */
 
 @import 'reset';
 
@@ -339,9 +339,9 @@ body {
 
 
 /* Os Placeholders são úteis na criação de uma declaração CSS para ampliar. Se você
-   deseja criar uma instrução CSS que foi usado exclusivamente com @extend,
-   você pode fazer isso usando um Placeholder. Placeholder começar com um '%' em vez
-   de '.' ou '#'. Placeholder não aparece no CSS compilado. */
+   deseja criar uma instrução CSS que foi usado exclusivamente com @extend,
+   você pode fazer isso usando um Placeholder. Placeholder começar com um '%' em vez
+   de '.' ou '#'. Placeholder não aparece no CSS compilado. */
 
 %content-window {
   font-size: 14px;
@@ -375,7 +375,7 @@ body {
 
 
 /* Sass fornece os seguintes operadores: +, -, *, /, e %. estes podem
-   ser úteis para calcular os valores diretamente no seu arquivos Sass em vez
+   ser úteis para calcular os valores diretamente no seu arquivos Sass em vez
    de usar valores que você já calcula manualmente. O exemplo abaixo é
    de um projeto simples de duas colunas. */
 

pt-br/stylus.md

@@ -12,7 +12,7 @@ A sintaxe do Stylus é muito flexivel podendo utilizar a sintaxe padrão do CSS
 
 Stylus não fornece novas opções de estilos, mas dá funcionalidades que permitem deixar seu CSS muito mais dinâmico.
 
-```sass
+```scss
 /* Estilo de código
 ==============================*/
 

pt-br/visualbasic.md

@@ -92,7 +92,7 @@ module Module1
         Console.Title = " Olá Mundo YourName | Saiba X em Y Minutes"
         ' Variáveis
         'Os dados inseridos por um usuário precisam ser armazenados.
-        ' As variáveis ​​também começar com um Dim e terminar com um Como VariableType.
+        ' As variáveis também começar com um Dim e terminar com um Como VariableType.
 
         ' Neste tutorial, nós queremos saber qual é o seu nome, e faça o programa
         ' Responder ao que é dito.
@@ -103,7 +103,7 @@ module Module1
         Console.WriteLine (" Olá " + username) ' A saída é "Olá < seu nome >".
         Console.ReadLine () ' Outsputs acima.
         ' O código acima irá lhe fazer uma pergunta seguiu imprimindo sua resposta.
-        " Outras variáveis ​​incluem Integer e usamos inteiro para números inteiros.
+        " Outras variáveis incluem Integer e usamos inteiro para números inteiros.
     End Sub
 
     "Três

raku.md

@@ -6,7 +6,7 @@ contributors:
     - ["Samantha McVey", "https://cry.nu"]
 ---
 
-Raku (formerly Perl 6) is a highly capable, feature-rich programming language
+Raku (formerly Perl 6) is a highly capable, feature-rich programming language
 made for at least the next hundred years.
 
 The primary Raku compiler is called [Rakudo](http://rakudo.org), which runs on

ru/c.md

@@ -33,7 +33,7 @@ translators:
 void function_1();
 void function_2();
 
-// Точка входа в программу – это функция main.
+// Точка входа в программу – это функция main.
 int main() {
     // для форматированного вывода в консоль используется printf
     // %d – означает, что будем выводить целое число, \n переводит указатель вывода
@@ -120,7 +120,7 @@ int main() {
     printf("%d\n", a_string[16]); // => 0
     // байт #17 тоже равен 0 (а также 18, 19, и 20)
 
-    // Если между одинарными кавычками есть символ – это символьный литерал,
+    // Если между одинарными кавычками есть символ – это символьный литерал,
     // но это тип int, а не char (по историческим причинам).
 
     int cha = 'a'; // хорошо
@@ -325,7 +325,7 @@ int main() {
 
     // Вы также можете динамически выделять несколько блоков памяти с помощью
     // функции malloc из стандартной библиотеки, которая принимает один
-    // аргумент типа size_t – количество байт необходимых для выделения.
+    // аргумент типа size_t – количество байт необходимых для выделения.
     int *my_ptr = malloc(sizeof(*my_ptr) * 20);
     for (xx = 0; xx < 20; xx++) {
         *(my_ptr + xx) = 20 - xx; // my_ptr[xx] = 20-xx

ru/linker.md

@@ -1,30 +1,26 @@
 ---
 contributors:
     - ["Alexander Kovalchuk", "https://github.com/Zamuhrishka"]
-translators:
-    - ["Alexander Kovalchuk", "https://github.com/Zamuhrishka"]
 ---
 
-# Основные понятия и определения
 **Счетчик позиций** - у компоновщика есть специальная переменная
-"." (точка) всегда содержит текущую позицию вывода.
+"`.`" (точка) всегда содержит текущую позицию вывода.
 
-# Функции
-**ADDR(section)** -  возвращает абсолютный адрес указанной секции. Однако 
+`ADDR(section)` - возвращает абсолютный адрес указанной секции. Однако
 данная секция должна быть определенна до использования функции ADDR.
 
-**ALIGN(exp)** -  возвращает значение счетчика позиций, выравненное на границу 
+`ALIGN(exp)` - возвращает значение счетчика позиций, выравненное на границу
 следующего за exp выражения.
 
-**SIZEOF(section)** -  возвращает размер секции в байтах.
+`SIZEOF(section)` - возвращает размер секции в байтах.
 
-**FILL(param)** -  определяет образец заполнения для текущей секции. Все 
+`FILL(param)` - определяет образец заполнения для текущей секции. Все
 остальные неуказанные регионы внутри секции заполняются значением указанными
 в аргументе функции.
 
-**KEEP(param)** -  используется чтобы помечать param как неустранимый.
+`KEEP(param)` - используется чтобы помечать param как неустранимый.
 
-**ENTRY(func)** -  определяет функцию, которая будет являться точкой входа 
+`ENTRY(func)` - определяет функцию, которая будет являться точкой входа
 в программу.
 
 ```bash
@@ -111,10 +107,10 @@ SECTIONS
 
 # ИТОГО: Секция .text, которая содержит код программы выравнивается по границе 4-х байт,
 # включает в себя: все секции с кодом программы во всех объектных файлах и защищенные
-от сборщика муссора секции .init и .fini во всех объектных файлах, распологается во FLASH 
-памяти микроконтроллера сразу за таблицей векторов. 
-Секции text, .init и .fini. располагаются в памяти в той последовательности в которой они 
-объявлены в скрипте.
+# от сборщика муссора секции .init и .fini во всех объектных файлах, распологается во FLASH
+# памяти микроконтроллера сразу за таблицей векторов.
+# Секции text, .init и .fini. располагаются в памяти в той последовательности в которой они
+# объявлены в скрипте.
 
   # Третья секция содержит константные данные.
   .rodata :
@@ -197,4 +193,3 @@ SECTIONS
   } >RAM
 }
 ```
-

stylus.md

@@ -15,7 +15,7 @@ Stylus syntax is very flexible. You can use standard CSS syntax and leave the se
 
 Stylus does not provide new style options, but gives functionality that lets you make your CSS much more dynamic.
 
-```sass
+```scss
 /* Code style
 ==============================*/
 
@@ -81,8 +81,8 @@ a {
 
 /*
   You can store a CSS value (such as the color) of a variable.
-  Although it is optional, it is recommended to add $ before a variable name
-  so you can distinguish a variable from another CSS value.
+  Although it is optional, it is recommended to add $ before a variable name
+  so you can distinguish a variable from another CSS value.
 */
 
 $primary-color = #A3A4FF

tr/edn.md

@@ -4,8 +4,6 @@ contributors:
   - ["Seçkin KÜKRER", "https://github.com/LeaveNhA"]
 ---
 
-# Y = 20 Dakika.
-
 ### Genişletilebilir Veri Notasyonu (EDN, Extensible Data Notation).
 
 ### Okunuşu: (Türkçe: ey-di-en), (English: eed-n)

tr/php.md

@@ -17,7 +17,7 @@ PHP 5+ versiyonu için geçerlidir.
 
 // // işareti ile tek satırlık yorum satırı başlar.
 
-# # işareti de aynı görevi görür ancak // daha genel kullanımdadır.
+# # işareti de aynı görevi görür ancak // daha genel kullanımdadır.
 
 
 
@@ -45,7 +45,7 @@ Hello World Again!
 *   Tipler ve Değişkenler
 *************************************/
 
-// Değişkenler $ sembolü ile başlar.
+// Değişkenler $ sembolü ile başlar.
 // Geçerli bir değişken bir harf veya alt çizgi ile başlar,
 // devamında da bir sayı, harf veya alt çizgi ile devam eder. 
 

tr/pythonlegacy.md

@@ -35,8 +35,8 @@ uygulanabilir. Python 3 için başka bir zaman tekrar bakınız.
 10 * 2 #=> 20
 35 / 5 #=> 7
 
-# Bölünme biraz ilginç. EĞer tam sayılar üzerinde bölünme işlemi yapıyorsanız
-# sonuç otomatik olarak kırpılır. 
+# Bölünme biraz ilginç. EĞer tam sayılar üzerinde bölünme işlemi yapıyorsanız
+# sonuç otomatik olarak kırpılır. 
 5 / 2 #=> 2
 
 # Bölünme işlemini düzenlemek için kayan noktalı sayıları bilmeniz gerekir.
@@ -80,30 +80,30 @@ not False #=> True
 "Hello " + "world!" #=> "Hello world!"
 
 # A string can be treated like a list of characters
-# Bir string'e karakter listesi gibi davranabilirsiniz. 
+# Bir string'e karakter listesi gibi davranabilirsiniz. 
 "This is a string"[0] #=> 'T'
 
 # % karakter dizisini(string) formatlamak için kullanılır, bunun gibi:
 "%s can be %s" % ("strings", "interpolated")
 
 # String'leri formatlamanın yeni bir yöntem ise format metodudur. 
-# Bu metod tercih edilen yöntemdir.
+# Bu metod tercih edilen yöntemdir.
 "{0} can be {1}".format("strings", "formatted")
-# Eğer saymak istemiyorsanız anahtar kelime kullanabilirsiniz.
+# Eğer saymak istemiyorsanız anahtar kelime kullanabilirsiniz.
 "{name} wants to eat {food}".format(name="Bob", food="lasagna")
 
 # None bir objedir
 None #=> None
 
-# "==" eşitliğini non objesi ile karşılaştırmak için kullanmayın.
-# Onun yerine "is" kullanın.
+# "==" eşitliğini non objesi ile karşılaştırmak için kullanmayın.
+# Onun yerine "is" kullanın.
 "etc" is None #=> False
 None is None  #=> True
 
 # 'is' operatörü obje kimliği için test etmektedir. Bu ilkel değerler
-# için kullanışlı değildir, ama objeleri karşılaştırmak için kullanışlıdır.
+# için kullanışlı değildir, ama objeleri karşılaştırmak için kullanışlıdır.
 
-# None, 0 ve boş string/list'ler False olarak değerlendirilir.
+# None, 0 ve boş string/list'ler False olarak değerlendirilir.
 # Tüm eşitlikler True döner
 0 == False  #=> True
 "" == False #=> True
@@ -122,12 +122,12 @@ some_var = 5    # Değişken isimlerinde gelenek küçük karakter ve alt çizgi
                 # kullanmaktır.
 some_var #=> 5
 
-# Daha önceden tanımlanmamış ya da assign edilmemeiş bir değişkene erişmeye 
-# çalıştığınızda bir hata fırlatılacaktır. Hata ayıklama hakkında daha fazla 
-# bilgi için kontrol akışı kısmına göz atınız.
+# Daha önceden tanımlanmamış ya da assign edilmemeiş bir değişkene erişmeye 
+# çalıştığınızda bir hata fırlatılacaktır. Hata ayıklama hakkında daha fazla 
+# bilgi için kontrol akışı kısmına göz atınız.
 some_other_var  # isim hatası fırlatılır
 
-# isterseniz "if"i bir ifade gibi kullanabilirsiniz.
+# isterseniz "if"i bir ifade gibi kullanabilirsiniz.
 "yahoo!" if 3 > 2 else 2 #=> "yahoo!"
 
 # Listeler
@@ -151,7 +151,7 @@ li[0] #=> 1
 li[-1] #=> 3
 
 # Listede bulunmayan bir index'teki elemana erişirken "IndexError" hatası 
-# fırlatılır 
+# fırlatılır 
 li[4] # IndexError fırlatılır
 
 # slice syntax'ı ile belli aralıktakı değerlere bakabilirsiniz.
@@ -177,7 +177,7 @@ li.extend(other_li) # Now li is [1, 2, 3, 4, 5, 6]
 # "len" ile listenin uzunluğunu bulmak
 len(li) #=> 6
 
-# Tüpler listeler gibidir sadece değişmezler(immutable)
+# Tüpler listeler gibidir sadece değişmezler(immutable)
 tup = (1, 2, 3)
 tup[0] #=> 1
 tup[0] = 3  # TypeError fırlatılır.
@@ -188,12 +188,12 @@ tup + (4, 5, 6) #=> (1, 2, 3, 4, 5, 6)
 tup[:2] #=> (1, 2)
 2 in tup #=> True
 
-# Tüplerin(veya listelerin) içerisindeki değerleri değişkenelere
+# Tüplerin(veya listelerin) içerisindeki değerleri değişkenelere
 # atanabilir
 a, b, c = (1, 2, 3)     # a şu anda 1, b şu anda 2 ve c şu anda 3
 # Eğer parantez kullanmaz iseniz tüpler varsayılan olarak oluşturulur
 d, e, f = 4, 5, 6
-# şimdi iki değeri değiş tokuş etmek çok kolaydır.
+# şimdi iki değeri değiş tokuş etmek çok kolaydır.
 e, d = d, e     # d şimdi 5 ve e şimdi 4
 
 
@@ -207,24 +207,24 @@ filled_dict["one"] #=> 1
 
 # Tüm anahtarlara(key) "keys()" metodu ile ulaşılır
 filled_dict.keys() #=> ["three", "two", "one"]
-# Not - Sözlüklerin anahtarlarının sıralı geleceği garanti değildir
-# Sonuçlarınız değer listesini aldığınızda tamamen eşleşmeyebilir 
+# Not - Sözlüklerin anahtarlarının sıralı geleceği garanti değildir
+# Sonuçlarınız değer listesini aldığınızda tamamen eşleşmeyebilir 
 
 # Tüm değerleri almak için "values()" kullanabilirsiniz.
 filled_dict.values() #=> [3, 2, 1]
 # Not - Sıralama ile ilgili anahtarlar ile aynı durum geçerlidir.
 
-# Bir anahtarın sözlükte oluş olmadığını "in" ile kontrol edilebilir
+# Bir anahtarın sözlükte oluş olmadığını "in" ile kontrol edilebilir
 "one" in filled_dict #=> True
 1 in filled_dict #=> False
 
-# Olmayan bir anahtar çağrıldığında KeyError fırlatılır.
+# Olmayan bir anahtar çağrıldığında KeyError fırlatılır.
 filled_dict["four"] # KeyError
 
-# "get()" metodu KeyError fırlatılmasını önler
+# "get()" metodu KeyError fırlatılmasını önler
 filled_dict.get("one") #=> 1
 filled_dict.get("four") #=> None
-# get() metodu eğer anahtar mevcut değilse varsayılan bir değer atama
+# get() metodu eğer anahtar mevcut değilse varsayılan bir değer atama
 # imknaı sağlar.
 filled_dict.get("one", 4) #=> 1
 filled_dict.get("four", 4) #=> 4
@@ -237,10 +237,10 @@ filled_dict.setdefault("five", 6) #filled_dict["five"] is still 5
 
 # Sets store ... well sets
 empty_set = set()
-# Bir demek değer ile bir "set" oluşturmak
+# Bir demek değer ile bir "set" oluşturmak
 some_set = set([1,2,2,3,4]) # some_set is now set([1, 2, 3, 4])
 
-# Python 2.7'den beri {}'ler bir "set" tanımlaman için kullanılabilir
+# Python 2.7'den beri {}'ler bir "set" tanımlaman için kullanılabilir
 filled_set = {1, 2, 2, 3, 4} # => {1 2 3 4}
 
 # Bir set'e daha fazla eleman eklemek
@@ -253,10 +253,10 @@ filled_set & other_set #=> {3, 4, 5}
 # | işareti ile 
 filled_set | other_set #=> {1, 2, 3, 4, 5, 6}
 
-# "-" işareti ile iki set'in farkları alınabilir
+# "-" işareti ile iki set'in farkları alınabilir
 {1,2,3,4} - {2,3,5} #=> {1, 4}
 
-# "in" ile değerin set içerisinde olup olmadığını kontrol edebilirsiniz
+# "in" ile değerin set içerisinde olup olmadığını kontrol edebilirsiniz
 2 in filled_set #=> True
 10 in filled_set #=> False
 
@@ -268,7 +268,7 @@ filled_set | other_set #=> {1, 2, 3, 4, 5, 6}
 # Bir değişken oluşturmak
 some_var = 5
 
-# Buradaki bir if ifadesi. Girintiler(Intentation) Python'da önemlidir!
+# Buradaki bir if ifadesi. Girintiler(Intentation) Python'da önemlidir!
 # "some_var is smaller than 10" yazdırılır.
 if some_var > 10:
     print "some_var is totally bigger than 10."
@@ -286,7 +286,7 @@ Ekrana yazdırılan:
     mouse is a mammal
 """
 for animal in ["dog", "cat", "mouse"]:
-    # Biçimlendirmeleri string'e katmak için % kullanabilirsiniz
+    # Biçimlendirmeleri string'e katmak için % kullanabilirsiniz
     print "%s is a mammal" % animal
     
 """
@@ -315,7 +315,7 @@ while x < 4:
 
 # try/except bloğu ile hatalar ayıklanabilir
 
-# Python 2.6 ve üstü için çalışacaktır:
+# Python 2.6 ve üstü için çalışacaktır:
 try:
     # "raise" bir hata fırlatmak için kullanılabilir
     raise IndexError("This is an index error")
@@ -339,18 +339,18 @@ add(5, 6) #=> prints out "x is 5 and y is 6" and returns 11
 # Diğer bir yol fonksiyonları anahtar argümanları ile çağırmak
 add(y=6, x=5)   # Anahtar argümanlarının sırası farklı da olabilir
 
-# Değişken sayıda parametresi olan bir fonksiyon tanımlayabilirsiniz
+# Değişken sayıda parametresi olan bir fonksiyon tanımlayabilirsiniz
 def varargs(*args):
     return args
 
 varargs(1, 2, 3) #=> (1,2,3)
 
-# Değişken sayıda anahtar argümanlı parametre alan fonksiyonlar da 
+# Değişken sayıda anahtar argümanlı parametre alan fonksiyonlar da 
 # tanımlayabilirsiniz.
 def keyword_args(**kwargs):
     return kwargs
 
-# Şu şekilde kullanılacaktır
+# Şu şekilde kullanılacaktır
 keyword_args(big="foot", loch="ness") #=> {"big": "foot", "loch": "ness"}
 
 # Eğer isterseniz ikisini aynı anda da yapabilirsiniz
@@ -363,15 +363,15 @@ all_the_args(1, 2, a=3, b=4) prints:
     {"a": 3, "b": 4}
 """
 
-# Fonksiyonu çağırırken, args/kwargs'ın tam tersini de yapabilirsiniz!
-# Tüpü yaymak için * ve kwargs'ı yaymak için ** kullanın.
+# Fonksiyonu çağırırken, args/kwargs'ın tam tersini de yapabilirsiniz!
+# Tüpü yaymak için * ve kwargs'ı yaymak için ** kullanın.
 args = (1, 2, 3, 4)
 kwargs = {"a": 3, "b": 4}
 all_the_args(*args) # foo(1, 2, 3, 4) ile eşit
 all_the_args(**kwargs) # foo(a=3, b=4) ile eşit
 all_the_args(*args, **kwargs) # foo(1, 2, 3, 4, a=3, b=4) ile eşit
 
-# Python first-class fonksiyonlara sahiptir
+# Python first-class fonksiyonlara sahiptir
 def create_adder(x):
     def adder(y):
         return x + y
@@ -387,7 +387,7 @@ add_10(3) #=> 13
 map(add_10, [1,2,3]) #=> [11, 12, 13]
 filter(lambda x: x > 5, [3, 4, 5, 6, 7]) #=> [6, 7]
 
-# Map etme(maps) ve filtreleme(filtres) için liste kullanabiliriz. 
+# Map etme(maps) ve filtreleme(filtres) için liste kullanabiliriz. 
 [add_10(i) for i in [1, 2, 3]]  #=> [11, 12, 13]
 [x for x in [3, 4, 5, 6, 7] if x > 5] #=> [6, 7]
 
@@ -399,7 +399,7 @@ filter(lambda x: x > 5, [3, 4, 5, 6, 7]) #=> [6, 7]
 # We subclass from object to get a class.
 class Human(object):
     
-    # Bir sınıf özelliği. Bu sınıfın tüm "instance"larına paylaşılmıştır.
+    # Bir sınıf özelliği. Bu sınıfın tüm "instance"larına paylaşılmıştır.
     species = "H. sapiens"
 
     # Basic initializer
@@ -408,18 +408,18 @@ class Human(object):
         # değişkenine atama
         self.name = name
 
-    # Bir instance metodu. Tüm metodlar ilk argüman olarak "self" 
+    # Bir instance metodu. Tüm metodlar ilk argüman olarak "self" 
     # parametresini alır
     def say(self, msg):
        return "%s: %s" % (self.name, msg)
 
     # Bir sınıf metodu tüm "instance"lar arasında paylaşılır
-    # İlk argüman olarak sınıfı çağırarak çağrılırlar
+    # İlk argüman olarak sınıfı çağırarak çağrılırlar
     @classmethod
     def get_species(cls):
         return cls.species
 
-    # Bir statik metod bir sınıf ya da instance referansı olmadan çağrılır
+    # Bir statik metod bir sınıf ya da instance referansı olmadan çağrılır
     @staticmethod
     def grunt():
         return "*grunt*"
@@ -452,24 +452,24 @@ Human.grunt() #=> "*grunt*"
 import math
 print math.sqrt(16) #=> 4.0
 
-# Modül içerisinden spesifik bir fonksiyonu getirebilirsiniz
+# Modül içerisinden spesifik bir fonksiyonu getirebilirsiniz
 from math import ceil, floor
 print ceil(3.7)  #=> 4.0
 print floor(3.7) #=> 3.0
 
 # Modüldeki tüm fonksiyonları dahil edebilirsiniz
-# Uyarı: bu önerilmez
+# Uyarı: bu önerilmez
 from math import *
 
-# Modülün adını kısaltabilirsiniz
+# Modülün adını kısaltabilirsiniz
 import math as m
 math.sqrt(16) == m.sqrt(16) #=> True
 
-# Python modülleri sıradan python dosyalarıdır. Kendinize bir modül 
-# yazabilirsiniz, ve dahil edebilirsiniz. Modülün adı ile dosya adı
-# aynı olmalıdır.
+# Python modülleri sıradan python dosyalarıdır. Kendinize bir modül 
+# yazabilirsiniz, ve dahil edebilirsiniz. Modülün adı ile dosya adı
+# aynı olmalıdır.
 
-# Modüllerde tanımlanmış fonksiyon ve metodları öğrenebilirsiniz.
+# Modüllerde tanımlanmış fonksiyon ve metodları öğrenebilirsiniz.
 import math
 dir(math)
 ```

vi/sass.md

@@ -16,7 +16,7 @@ Bài hướng dẫn này sử dụng SCSS.
 
 Nếu bạn đọc đã quen thuộc với CSS3 thì sẽ tương đối nhanh chóng để nắm được Sass. Nó không cung cấp thuộc tính để style CSS mới nhưng đưa ra những công cụ để có thể viết CSS hiệu quả hơn và có thể bảo trì dễ dàng hơn.
 
-```sass
+```scss
 // Comment (chú thích) một dòng sẽ bị xóa khi Less được biên dịch thành CSS
 
 /* Comment trên nhiều dòng sẽ được giữ lại */

vim9script.md

@@ -0,0 +1,443 @@
+---
+name: Vim9script
+filename: learn9vimscript.vim
+contributors:
+    - ["HiPhish", "http://hiphish.github.io/"]
+---
+
+```vim
+# ##############
+#  Introduction
+# ##############
+
+# Vim9 script is a modernized version of Vim's scripting language, offering features like variables, functions, and loops.
+# Accoding to `:help vim9-differences`, the principal differences from legacy Vim script are as follows:
+# 
+# - Comments start with #, not ": >
+# 	echo "hello"   # comment
+# - Using a backslash for line continuation is hardly ever needed: >
+# 	echo "hello "
+# 	     .. yourName
+# 	     .. ", how are you?"
+# - White space is required in many places to improve readability.
+# - Assign values without `:let` *E1126* , declare variables with `:var`: >
+# 	var count = 0
+# 	count += 3
+# - Constants can be declared with `:final` and `:const`: >
+# 	final matches = []		  # add to the list later
+# 	const names = ['Betty', 'Peter']  # cannot be changed
+# - `:final` cannot be used as an abbreviation of `:finally`.
+# - Variables and functions are script-local by default.
+# - Functions are declared with argument types and return type: >
+# 	def CallMe(count: number, message: string): bool
+# - Call functions without `:call`: >
+# 	writefile(['done'], 'file.txt')
+# - You cannot use old Ex commands:
+# 	`:Print`
+# 	`:append`
+# 	`:change`
+# 	`:d`  directly followed by 'd' or 'p'.
+# 	`:insert`
+# 	`:k`
+# 	`:mode`
+# 	`:open`
+# 	`:s`  with only flags
+# 	`:t`
+# 	`:xit`
+# - Some commands, especially those used for flow control, cannot be shortened.
+#   E.g., `:throw` cannot be written as `:th`.  *vim9-no-shorten*
+# - You cannot use curly-braces names.
+# - A range before a command must be prefixed with a colon: >
+# 	:%s/this/that
+# - Executing a register with "@r" does not work, you can prepend a colon or use
+#   `:exe`: >
+# 	:exe @a
+# - Unless mentioned specifically, the highest |scriptversion| is used.
+# - When defining an expression mapping, the expression will be evaluated in the
+#   context of the script where it was defined.
+# - When indexing a string the index is counted in characters, not bytes:
+#   |vim9-string-index|
+# - Some possibly unexpected differences: |vim9-gotchas|.
+#
+# You can run Vim9 script commands in command-line mode or write them to a file and source it in Vim.
+# This guide assumes familiarity with ex-commands and focuses on scripting.
+
+# Comments start with #
+# The vertical line '|' separates commands
+echo 'Hello' | echo 'world!'
+
+# Putting a comment after a command usually works
+pwd  # Displays the current working directory
+
+# Line continuation is rarely needed
+echo "Hello "
+     .. "world"
+
+echo [1, 2]
+
+echo {
+    'a': 1,
+    'b': 2
+}
+
+# #######
+#  Types
+# #######
+
+# Numbers
+echo 123         # Decimal
+echo 0b1111011   # Binary
+echo 0173        # Octal
+echo 0x7B        # Hexadecimal
+echo 123.0       # Floating-point
+echo 1.23e2      # Floating-point (scientific notation)
+
+# Booleans
+echo true      # Evaluates to true
+echo false     # Evaluates to false
+
+# Boolean values from comparison
+echo x == y      # Equality by value
+echo x != y      # Inequality
+echo x > y       # Greater than
+echo x >= y      # Greater than or equal
+echo x < y       # Smaller than
+echo x <= y      # Smaller than or equal
+echo x is y      # Instance identity
+echo x isnot y   # Instance non-identity
+
+# Strings
+echo 'a' < 'B'   # True or false depending on 'ignorecase'
+echo 'a' <? 'B'  # True
+echo 'a' <# 'B'  # False
+
+# Regular expression matching
+echo "hi" =~ "hello"    # Regular expression match
+echo "hi" =~# "hello"   # Case sensitive
+echo "hi" =~? "hello"   # Case insensitive
+echo "hi" !~ "hello"    # Regular expression unmatch
+echo "hi" !~# "hello"   # Case sensitive
+echo "hi" !~? "hello"   # Case insensitive
+
+# Boolean operations
+echo true && false  # Logical AND
+echo true || false  # Logical OR
+echo !true            # Logical NOT
+echo true ? 'yes' : 'no'  # Ternary operator
+
+# Strings
+echo "Hello world\n"   # Newline
+echo 'Hello world\n'   # Literal
+echo 'Let''s go!'      # Two single quotes become one
+
+# String concatenation
+echo 'Hello ' .. 'world'  # String concatenation
+
+# String indexing
+echo 'Hello'[0]           # First character
+echo 'Hello'[1]           # Second character
+echo 'Hellö'[4]           # Returns a character
+
+# Substrings
+echo 'Hello'[:]           # Copy of entire string
+echo 'Hello'[1:3]         # Substring
+echo 'Hello'[1:-2]        # Substring until second to last character
+echo 'Hello'[1:]          # Substring with starting index
+echo 'Hello'[:2]          # Substring with ending index
+echo 'Hello'[-2:]         # Substring relative to end
+
+# Lists
+echo []                   # Empty list
+echo [1, 2, 'Hello']      # List with elements
+echo [1, 2, 'Hello', ]    # Trailing comma permitted
+echo [[1, 2], 'Hello']    # Nested lists
+
+# List concatenation
+echo [1, 2] + [3, 4]      # Creates a new list
+
+# List indexing
+echo [1, 2, 3, 4][2]      # Third element
+echo [1, 2, 3, 4][-1]     # Last element
+
+# List slicing
+echo [1, 2, 3, 4][:]      # Shallow copy
+echo [1, 2, 3, 4][:2]     # Sublist until third item
+echo [1, 2, 3, 4][2:]     # Sublist from third item
+echo [1, 2, 3, 4][:-2]    # Sublist until second-to-last item
+
+# Dictionaries
+echo {}                       # Empty dictionary
+echo {'a': 1, 'b': 2}         # Dictionary literal
+echo {'a': 1, 'b': 2, }       # Trailing comma permitted
+echo {'x': {'a': 1, 'b': 2}}  # Nested dictionary
+
+# Indexing a dictionary
+echo {'a': 1, 'b': 2}['a']    # Literal index
+echo {'a': 1, 'b': 2}.a       # Syntactic sugar
+
+# Funcref
+echo function('type')         # Reference to function type()
+echo {x -> x * x}             # Anonymous function
+
+# Regular expression
+substitute/hello/Hello/
+
+# ###########################
+#  Implicit type conversions
+# ###########################
+
+echo "1" + 1         # Number
+echo "1" .. 1        # String
+echo "0xA" + 1       # Number
+
+# ###########
+#  Variables
+# ###########
+
+var b:my_var = 1        # Local to current buffer
+var w:my_var = 1        # Local to current window
+var t:my_var = 1        # Local to current tab page
+var g:my_var = 1        # Global variable
+
+# Access special Vim memory like variables
+var @a = 'Hello'        # Register
+var $PATH=''            # Environment variable
+var &textwidth = 79     # Option
+var &l:textwidth = 79   # Local option
+var &g:textwidth = 79   # Global option
+
+# Access scopes as dictionaries
+echo b:                # All buffer variables
+echo w:                # All window variables
+echo t:                # All tab page variables
+echo g:                # All global variables
+echo v:                # All Vim variables
+
+# Constant variables
+const x = 10            # Constant
+
+# Function reference variables
+var IsString = {x -> type(x) == type('')}    # Global
+var isNumber = {x -> type(x) == type(0)}   # Local
+
+# Multiple value binding
+var [x, y] = [1, 2]
+
+# Assign the remainder to a rest variable
+var [mother, father; children] = ['Alice', 'Bob', 'Carol', 'Dennis', 'Emily']
+
+# ##############
+#  Flow control
+# ##############
+
+# Conditional
+var condition = true
+
+if condition
+    echo 'First condition'
+elseif another_condition
+    echo 'Second condition'
+else
+    echo 'Fail'
+endif
+
+# Loops
+
+# For-loop
+for person in ['Alice', 'Bob', 'Carol', 'Dennis', 'Emily']
+    echo 'Hello ' .. person
+endfor
+
+# Iterate over a nested list
+for [x, y] in [[1, 0], [0, 1], [-1, 0], [0, -1]]
+    echo 'Position: x =' .. x .. ', y = ' .. y
+endfor
+
+# Iterate over a range of numbers
+for i in range(10, 0, -1)
+    echo 'T minus' .. i
+endfor
+
+# Iterate over the keys of a dictionary
+for symbol in keys({'π': 3.14, 'e': 2.71})
+    echo 'The constant ' .. symbol .. ' is a transcendent number'
+endfor
+
+# Iterate over the values of a dictionary
+for value in values({'π': 3.14, 'e': 2.71})
+    echo 'The value ' .. value .. ' approximates a transcendent number'
+endfor
+
+# Iterate over the keys and values of a dictionary
+for [symbol, value] in items({'π': 3.14, 'e': 2.71})
+    echo 'The number ' .. symbol .. ' is approximately ' .. value
+endfor
+
+# While-loops
+var there_yet = true
+while !there_yet
+    echo 'Are we there yet?'
+endwhile
+
+# Exception handling
+try
+    source path/to/file
+catch /Cannot open/
+    echo 'Looks like that file does not exist'
+catch /.*/
+    echo 'Something went wrong, but I do not know what'
+finally
+    echo 'I am done trying'
+endtry
+
+# ##########
+#  Functions
+# ##########
+
+# Defining functions
+def AddNumbersLoudly(x: number, y: number): number
+    echo 'Adding' .. x .. 'and' .. y
+    return x + y
+enddef
+
+def s:addNumbersLoudly(x: number, y: number): number
+    echo 'Adding' .. x .. 'and' .. y
+    return x + y
+enddef
+
+# Range functions
+def FirstAndLastLine() range
+    echo [a:firstline, a:lastline]
+enddef
+
+# Aborting functions
+def SourceMyFile() abort
+    source my-file.vim
+    echo 'This will never be printed'
+enddef
+
+# Closures
+def MakeAdder(x: number)
+    def Adder(n: number) closure
+        return n + x
+    enddef
+    return funcref('Adder')
+enddef
+var AddFive = MakeAdder(5)
+echo AddFive(3)  # Prints 8
+
+# Dictionary functions
+def Mylen() dict
+    return len(self.data)
+enddef
+var mydict = {'data': [0, 1, 2, 3], 'len': function("Mylen")}
+echo mydict.len()
+
+# Alternatively, more concise
+var mydict = {'data': [0, 1, 2, 3]}
+def mydict.len()
+    return len(self.data)
+enddef
+
+# Calling functions
+var animals = keys({'cow': 'moo', 'dog': 'woof', 'cat': 'meow'})
+
+# Call a function for its side effects only
+call sign_undefine()
+
+# The call() function
+echo call(function('get'), [{'a': 1, 'b': 2}, 'c', 3])  # Prints 3
+
+# Function namespaces
+def foo#bar#log(value: string)
+    echomsg value
+enddef
+
+call foo#bar#log('Hello')
+
+# #############################
+#  Frequently used ex-commands
+# #############################
+
+# Sourcing runtime files
+runtime plugin/my-plugin.vim
+
+# Defining new ex-commands
+command! SwapAdjacentLines normal! ddp
+
+command! -nargs=1 Error echoerr <args>
+
+# Defining auto-commands
+autocmd BufWritePost $MYVIMRC source $MYVIMRC
+
+# Auto groups
+augroup auto-source
+    autocmd!
+    autocmd BufWritePost $MYVIMRC source $MYVIMRC
+augroup END
+
+# Executing
+var line = 3
+execute line .. 'delete'
+
+# Executing normal-mode commands
+normal! ggddGp
+
+# Window commands
+wincmd L
+
+# ###########################
+#  Frequently used functions
+# ###########################
+
+# Feature check
+echo has('nvim')
+echo has('python3')
+echo has('unix')
+echo has('win32')
+
+# Test if something exists
+echo exists('&mouse')
+echo exists('+mouse')
+echo exists('$HOSTNAME')
+echo exists('*strftime')
+echo exists('**s:MyFunc')
+echo exists('bufcount')
+echo exists('my_dict["foo"]')
+echo exists(':Make')
+echo exists("#CursorHold")
+echo exists("#BufReadPre#*.gz")
+echo exists("#filetypeindent")
+echo exists("##ColorScheme")
+
+# Various dynamic values
+echo expand('%')
+echo expand('<cword>')
+echo expand('%:p')
+
+# Type tests
+echo type(my_var) == v:t_number
+echo type(my_var) == v:t_string
+echo type(my_var) == v:t_func
+echo type(my_var) == v:t_list
+echo type(my_var) == v:t_dict
+echo type(my_var) == v:t_float
+echo type(my_var) == v:t_bool
+echo my_var is v:null
+
+# Format strings
+echo printf('%d in hexadecimal is %X', 123, 123)
+
+# #####################
+#  Tricks of the trade
+# #####################
+
+# Source guard
+if exists('g:loaded_my_plugin')
+    finish
+endif
+var g_loaded_my_plugin = true
+
+# Default values
+var greeting = get(g:, 'my_plugin_greeting', 'Hello')
+```

wolfram.md

@@ -139,6 +139,6 @@ Manipulate[y^2, {y, 0, 20}] (* Return a reactive user interface that displays y^
                                Only works on graphical frontends *)
 ```
 
-##Ready For More?
+## Further reading
 
 * [Wolfram Language Documentation Center](http://reference.wolfram.com/language/)

zh-cn/vim.md

@@ -53,15 +53,15 @@ translators:
     t<字符>         # 向前跳移到 <字符> 的左侧
 
     # 例如，
-    f<               # 向前跳移到 < 上
+    f<               # 向前跳移到 < 上
     t<               # 向前跳移到 < 的左侧
 
     # 按词移动
     # 默认一个单词由字母，数字和下划线组成
 
-    w                # 移动到下一个词首
-    b                # 移动到前一个词首
-    e                # 移动到下一个词尾
+    w                # 移动到下一个词首
+    b                # 移动到前一个词首
+    e                # 移动到下一个词尾
 
 
     # 移动的其它命令