unify header style

.github/workflows/lint.yml

@@ -1,4 +1,4 @@
-name: Node.js CI
+name: CI
 
 on:
   push:
@@ -15,4 +15,4 @@ jobs:
         with:
           ruby-version: '3.2'
       - run: gem install mdl
-      - run: mdl . --ignore-front-matter -r MD011,MD023,MD027,MD028,MD037,MD038,MD039,MD047
+      - run: mdl . --ignore-front-matter -r MD003,MD011,MD023,MD027,MD028,MD035,MD037,MD038,MD039,MD047

chapel.html.markdown

@@ -1116,8 +1116,7 @@ proc main() {
 } // end main()
 ```
 
-Who is this tutorial for?
+## Who is this tutorial for?
--------------------------
 
 This tutorial is for people who want to learn the ropes of chapel without
 having to hear about what fiber mixture the ropes are, or how they were
@@ -1132,28 +1131,27 @@ to see if more topics have been added or more tutorials created.
 
 ### What this tutorial is lacking:
 
- * Exposition of the [standard modules](https://chapel-lang.org/docs/latest/modules/standard.html)
+* Exposition of the [standard modules](https://chapel-lang.org/docs/latest/modules/standard.html)
- * Multiple Locales (distributed memory system)
+* Multiple Locales (distributed memory system)
- * Records
+* Records
- * Parallel iterators
+* Parallel iterators
 
-Your input, questions, and discoveries are important to the developers!
+## Your input, questions, and discoveries are important to the developers!
------------------------------------------------------------------------
 
 The Chapel language is still in active development, so there are
 occasional hiccups with performance and language features. The more information
 you give the Chapel development team about issues you encounter or features you
 would like to see, the better the language becomes.
 There are several ways to interact with the developers:
-+ [Gitter chat](https://gitter.im/chapel-lang/chapel)
+
-+ [sourceforge email lists](https://sourceforge.net/p/chapel/mailman)
+* [Gitter chat](https://gitter.im/chapel-lang/chapel)
+* [sourceforge email lists](https://sourceforge.net/p/chapel/mailman)
 
 If you're really interested in the development of the compiler or contributing
 to the project, [check out the master GitHub repository](https://github.com/chapel-lang/chapel).
 It is under the [Apache 2.0 License](http://www.apache.org/licenses/LICENSE-2.0).
 
-Installing the Compiler
+## Installing the Compiler
------------------------
 
 [The Official Chapel documentation details how to download and compile the Chapel compiler.](https://chapel-lang.org/docs/usingchapel/QUICKSTART.html)
 
@@ -1161,23 +1159,22 @@ Chapel can be built and installed on your average 'nix machine (and cygwin).
 [Download the latest release version](https://github.com/chapel-lang/chapel/releases/)
 and it's as easy as
 
- 1. `tar -xvf chapel-<VERSION>.tar.gz`
+1. `tar -xvf chapel-<VERSION>.tar.gz`
- 2. `cd chapel-<VERSION>`
+2. `cd chapel-<VERSION>`
- 3. `source util/setchplenv.bash # or .sh or .csh or .fish`
+3. `source util/setchplenv.bash # or .sh or .csh or .fish`
- 4. `make`
+4. `make`
- 5. `make check # optional`
+5. `make check # optional`
 
 You will need to `source util/setchplenv.EXT` from within the Chapel directory
 (`$CHPL_HOME`) every time your terminal starts so it's suggested that you drop
 that command in a script that will get executed on startup (like .bashrc).
 
-Chapel is easily installed with Brew for macOS
+Chapel is easily installed on macOS with Homebrew
 
- 1. `brew update`
+1. `brew update`
- 2. `brew install chapel`
+2. `brew install chapel`
 
-Compiling Code
+## Compiling Code
---------------
 
 Builds like other compilers:
 
@@ -1185,10 +1182,10 @@ Builds like other compilers:
 
 Notable arguments:
 
- * `--fast`: enables a number of optimizations and disables array bounds
+* `--fast`: enables a number of optimizations and disables array bounds
-   checks. Should only enable when application is stable.
+  checks. Should only enable when application is stable.
- * `--set <Symbol Name>=<Value>`: set config param `<Symbol Name>` to `<Value>`
+* `--set <Symbol Name>=<Value>`: set config param `<Symbol Name>` to `<Value>`
-   at compile-time.
+  at compile-time.
- * `--main-module <Module Name>`: use the main() procedure found in the module
+* `--main-module <Module Name>`: use the main() procedure found in the module
-   `<Module Name>` as the executable's main.
+  `<Module Name>` as the executable's main.
- * `--module-dir <Directory>`: includes `<Directory>` in the module search path.
+* `--module-dir <Directory>`: includes `<Directory>` in the module search path.

es-es/chapel-es.html.markdown

@@ -11,10 +11,9 @@ lang: es-es
 
 Puede leer todo sobre Chapel en [el sitio web oficial de Chapel de Cray](https://chapel-lang.org).
 En resumen, Chapel es un lenguaje de programación paralela, código abierto, de alta productividad
-desarrolladp en Cray Inc. y está diseñado para ejecutarse en PC multi-nucleos, 
+desarrolladp en Cray Inc. y está diseñado para ejecutarse en PC multi-nucleos,
 así como en supercomputadoras multi-kilocore.
 
-
 Puede encontrar más información y asistencia al final de este documento.
 
 ```chapel
@@ -39,7 +38,7 @@ stdout.writeln("Esto va a la salida estándar, al igual que lo hace writeln()");
 stderr.writeln("Esto va al error estándar");
 
 
-// Las variables no tienen que escribirse explícitamente 
+// Las variables no tienen que escribirse explícitamente
 // mientras el compilador pueda determinar el tipo que contendrá.
 
 // 10 es un entero, asi que myVar es explícitamente un entero
@@ -86,7 +85,7 @@ var white: RGBColor = (255, 255, 255);
 // establecerla en tiempo de ejecución.
 const almostPi: real = 22.0/7.0;
 
-// Un parámetro es una constante cuyo valor debe conocerse estáticamente 
+// Un parámetro es una constante cuyo valor debe conocerse estáticamente
 // en tiempo de compilación.
 
 param compileTimeConst: int = 16;
@@ -103,8 +102,8 @@ writeln(varCmdLineArg, ", ", constCmdLineArg, ", ", paramCmdLineArg);
 
 // Referencias
 
-// ref funciona de manera muy similar a una referencia en C ++. En Chapel, 
+// ref funciona de manera muy similar a una referencia en C ++. En Chapel,
-// no se puede hacer una referencia como alias a una variable distinta 
+// no se puede hacer una referencia como alias a una variable distinta
 // de la variable con la que se inicializa.
 
 // Aquí, refToActual se refiere a actual.
@@ -152,7 +151,7 @@ a *= thatInt;          // Multiplicación-igual (a = a * thatInt;)
 b &&= thatBool;        // Lógico e igual (b = b && thatBool;)
 a <<= 3;               // Desplazamiento a la izquierda igual (a = a << 10;)
 
-// A diferencia de otros lenguajes de familia C, no hay operadores de 
+// A diferencia de otros lenguajes de familia C, no hay operadores de
 // pre / post-incremento / decremento, tales como:
 //
 // ++j, --j, j++, j--
@@ -185,7 +184,7 @@ diffTup(1) = -1;
 var (tupInt, tupReal, tupCplx) = diffTup;
 writeln(diffTup == (tupInt, tupReal, tupCplx));
 
-// También son útiles para imprimit una lista de variables, 
+// También son útiles para imprimit una lista de variables,
 // como es común en la depuración.
 writeln((a,b,thisInt,thatInt,thisBool,thatBool));
 
@@ -223,7 +222,7 @@ if a % 3 == 0 {
 var maximum = if thisInt < thatInt then thatInt else thisInt;
 
 // las declaraciones select son muy parecidas a las declaraciones switch
-// en otros idiomas. Sin embargo, las declaraciones select no caen 
+// en otros idiomas. Sin embargo, las declaraciones select no caen
 // en cascada como en C o Java.
 var inputOption = "anOption";
 select inputOption {
@@ -253,7 +252,7 @@ do {
 } while (j <= 10000);
 writeln(jSum);
 
-// Los bucles for son muy parecidos a los de Python porque iteran en un rango. 
+// Los bucles for son muy parecidos a los de Python porque iteran en un rango.
 // Los rangos (como la expresión 1..10 a continuación) son un objeto de primera clase
 // en Chapel, y como tal pueden almacenarse en variables.
 for i in 1..10 do write(i, ", ");
@@ -275,8 +274,8 @@ for x in 1..10 {
 // Rangos y Dominios
 
 // Los bucles y matrices utilizan rangos y dominios para definir un conjunto de índices
-// que se pueden iterar. Los rangos son índices enteros unidimensionales, mientras 
+// que se pueden iterar. Los rangos son índices enteros unidimensionales, mientras
-// que los dominios pueden ser multidimensionales y representan índices 
+// que los dominios pueden ser multidimensionales y representan índices
 // de diferentes tipos.
 
 // Son tipos ciudadanos de primera clase y pueden asignarse a variables.
@@ -296,7 +295,7 @@ var reverse2to10by2 = 2..10 by -2; // 10, 8, 6, 4, 2
 var trapRange = 10..1 by -1; // No te dejes engañar, esto sigue siendo un rango vacío
 writeln("Size of range ", trapRange, " = ", trapRange.length);
 
-// Note: range(boundedType= ...) and range(stridable= ...) solo son necesarios 
+// Note: range(boundedType= ...) and range(stridable= ...) solo son necesarios
 // si escribimos explícitamente la variable.
 
 // El punto final de un rango se puede determinar utilizando el operador de conteo (#).
@@ -316,7 +315,7 @@ for i in rangeCountBy {
   write(i, if i == rangeCountBy.last then "\n" else ", ");
 }
 
-// Los dominios rectangulares se definen usando la misma sintaxis de rango, 
+// Los dominios rectangulares se definen usando la misma sintaxis de rango,
 // pero se requiere que estén delimitados (a diferencia de los rangos).
 var domain1to10: domain(1) = {1..10};        // 1D domain from 1..10;
 var twoDimensions: domain(2) = {-2..2,0..2}; // 2D domain over product of ranges
@@ -352,7 +351,7 @@ writeln(stringSet.sorted());
 // Los dominios asociativos también pueden tener una sintaxis literal
 var intSet = {1, 2, 4, 5, 100};
 
-// Tanto los rangos como los dominios se pueden dividir para producir un rango 
+// Tanto los rangos como los dominios se pueden dividir para producir un rango
 // o dominio con la intersección de los índices.
 var rangeA = 1.. ; // range from 1 to infinity
 var rangeB =  ..5; // range from negative infinity to 5
@@ -377,7 +376,7 @@ for i in 1..10 do
 writeln(intArray);
 
 // No podemos acceder a intArray[0] porque existe fuera del conjunto de índices,
-// {1..10}, que definimos al principio. 
+// {1..10}, que definimos al principio.
 // intArray [11] es ilegal por la misma razón.
 var realDomain: domain(2) = {1..5,1..7};
 var realArray: [realDomain] real;
@@ -431,12 +430,12 @@ writeln((thisArray, thatArray));
 thatArray[4..5] = thisArray[1..2];
 writeln((thisArray, thatArray));
 
-// Las operaciones también se pueden promover para trabajar en arreglos. 
+// Las operaciones también se pueden promover para trabajar en arreglos.
 // 'thisPlusThat' también es una matriz.
 var thisPlusThat = thisArray + thatArray;
 writeln(thisPlusThat);
 
-// Continuando, las matrices y los bucles también pueden ser expresiones, donde 
+// Continuando, las matrices y los bucles también pueden ser expresiones, donde
 // la expresión del cuerpo del bucle es el resultado de cada iteración.
 var arrayFromLoop = for i in 1..10 do i;
 writeln(arrayFromLoop);
@@ -494,11 +493,11 @@ writeln(defaultsProc(x=11));
 writeln(defaultsProc(x=12, y=5.432));
 writeln(defaultsProc(y=9.876, x=13));
 
-// El operador ? se llama operador de consulta y se usa para tomar valores 
+// El operador ? se llama operador de consulta y se usa para tomar valores
-// indeterminados como tuplas o tamaños de matriz y tipos genéricos. 
+// indeterminados como tuplas o tamaños de matriz y tipos genéricos.
-// Por ejemplo, tomar matrices como parámetros. 
+// Por ejemplo, tomar matrices como parámetros.
 
-// El operador de consulta se utiliza para determinar el dominio de A. 
+// El operador de consulta se utiliza para determinar el dominio de A.
 // Esto es útil para definir el tipo de retorno, aunque no es obligatorio.
 proc invertArray(A: [?D] int): [D] int{
   for a in A do a = -a;
@@ -523,9 +522,9 @@ genericProc(1.2, 2.3);
 genericProc(1.0+2.0i, 3.0+4.0i);
 
 // También podemos imponer una forma de polimorfismo con la cláusula where
-// Esto permite que el compilador decida qué función usar. 
+// Esto permite que el compilador decida qué función usar.
 
-// Nota: Eso significa que toda la información debe conocerse en tiempo de compilación. 
+// Nota: Eso significa que toda la información debe conocerse en tiempo de compilación.
 // El modificador param en el argumento se usa para imponer esta restricción.
 proc whereProc(param N : int): void
  where (N > 0) {
@@ -541,7 +540,7 @@ whereProc(10);
 whereProc(-1);
 
 // whereProc(0) daría lugar a un error del compilador porque no hay funciones
-// que satisfagan la condición de la cláusula where. 
+// que satisfagan la condición de la cláusula where.
 // Podríamos haber definido un whereProc sin una cláusula where que
 // hubiera servido como captura para todos los demás casos (de los cuales solo hay uno).
 
@@ -583,9 +582,9 @@ writeln("Afuera antes: ", (inVar, outVar, inoutVar, refVar));
 intentsProc(inVar, outVar, inoutVar, refVar);
 writeln("Afuera después: ", (inVar, outVar, inoutVar, refVar));
 
-// Del mismo modo, podemos definir intentos en el tipo de retorno. 
+// Del mismo modo, podemos definir intentos en el tipo de retorno.
-// refElement devuelve una referencia a un elemento de la matriz. Esto tiene más sentido 
+// refElement devuelve una referencia a un elemento de la matriz. Esto tiene más sentido
-// práctico para los métodos de clase donde las referencias a elementos en una estructura 
+// práctico para los métodos de clase donde las referencias a elementos en una estructura
 // de datos se devuelven a través de un método o iterador.
 proc refElement(array : [?D] ?T, idx) ref : T {
   return array[idx];
@@ -638,12 +637,12 @@ writeln(1 * 2);   // Utiliza el operador predeterminado *.
 
 // Iteradores
 
-// Los iteradores son hermanas del procedimiento, y casi todo lo relacionado 
+// Los iteradores son hermanas del procedimiento, y casi todo lo relacionado
-// con los procedimientos también se aplica a los iteradores. Sin embargo, en lugar de 
+// con los procedimientos también se aplica a los iteradores. Sin embargo, en lugar de
 // devolver un solo valor, los iteradores pueden generar múltiples valores en un bucle.
 
-// Esto es útil cuando se necesita un conjunto u orden complicado de iteraciones, 
+// Esto es útil cuando se necesita un conjunto u orden complicado de iteraciones,
-// ya que permite que el código que define las iteraciones 
+// ya que permite que el código que define las iteraciones
 // se separe del cuerpo del bucle.
 iter oddsThenEvens(N: int): int {
   for i in 1..N by 2 do
@@ -668,13 +667,13 @@ for i in absolutelyNothing(10) {
   writeln("Woa there! absolutelyNothing yielded ", i);
 }
 
-// Podemos comprimir dos o más iteradores (que tienen el mismo número de iteraciones) 
+// Podemos comprimir dos o más iteradores (que tienen el mismo número de iteraciones)
-// usando zip () para crear un solo iterador comprimido, donde cada iteración 
+// usando zip () para crear un solo iterador comprimido, donde cada iteración
 // del iterador comprimido produce una tupla de un valor de cada iterador.
 for (positive, negative) in zip(1..5, -5..-1) do
   writeln((positive, negative));
 
-// La iteración de la cremallera es bastante importante en la asignación de matrices, 
+// La iteración de la cremallera es bastante importante en la asignación de matrices,
 // segmentos de matrices y expresiones de matriz / bucle.
 var fromThatArray : [1..#5] int = [1,2,3,4,5];
 var toThisArray : [100..#5] int;
@@ -696,7 +695,7 @@ for (i, j) in zip(toThisArray.domain, -100..#5) {
 writeln(toThisArray);
 
 /*
- Esto es muy importante para entender por qué esta declaración 
+ Esto es muy importante para entender por qué esta declaración
  exhibe un error de tiempo de ejecución.
 */
 
@@ -718,16 +717,16 @@ class MyClass {
   var memberInt : int;
   var memberBool : bool = true;
 
-// Inicializador definido explícitamente. 
+// Inicializador definido explícitamente.
 // También obtenemos el inicializador generado por el compilador, con un argumento por campo.
-// Tenga en cuenta que pronto no habrá un inicializador generado por el compilador 
+// Tenga en cuenta que pronto no habrá un inicializador generado por el compilador
 // cuando definamos los inicializadores explícitamente.
   proc init(val : real) {
     this.memberInt = ceil(val): int;
   }
 
 // Desinicializador explícitamente definido.
-// Si no escribiéramos uno, obtendríamos el desinicializador generado por el compilador, 
+// Si no escribiéramos uno, obtendríamos el desinicializador generado por el compilador,
 // que tiene un cuerpo vacío.
   proc deinit() {
     writeln("MyClass deinitializer called ", (this.memberInt, this.memberBool));
@@ -751,7 +750,7 @@ class MyClass {
   }
 } // termina MyClass
 
-// Llame al inicializador generado por el compilador, 
+// Llame al inicializador generado por el compilador,
 // utilizando el valor predeterminado para memberBool.
 var myObject = new MyClass(10);
     myObject = new MyClass(memberInt = 10); // Equivalente
@@ -801,8 +800,8 @@ class GenericClass {
 
 // Copiar constructor.
 // Nota: Todavía tenemos que poner el tipo como argumento, pero podemos usar
-// el operador de consulta (?) como predeterminado para el tipo del otro objeto. 
+// el operador de consulta (?) como predeterminado para el tipo del otro objeto.
-// Además, podemos aprovechar esto para permitir a nuestro constructor de copias 
+// Además, podemos aprovechar esto para permitir a nuestro constructor de copias
 // copiar clases de diferentes tipos y emitir sobre la marcha.
   proc GenericClass(other : GenericClass(?otherType),
                      type classType = otherType) {
@@ -818,7 +817,7 @@ class GenericClass {
     return this.classArray[i];
   }
 
-// Definir un iterador implícito para que la clase produzca 
+// Definir un iterador implícito para que la clase produzca
 // valores de la matriz a un bucle
 // i.e. for i in objVar do ...
   iter these() ref : classType {
@@ -827,12 +826,12 @@ class GenericClass {
   }
 } // end GenericClass
 
-// Podemos asignar a la matriz de miembros del objeto usando la notación de 
+// Podemos asignar a la matriz de miembros del objeto usando la notación de
 // corchete que definimos.
 var realList = new GenericClass(real, 10);
 for i in realList.classDomain do realList[i] = i + 1.0;
 
-// Podemos iterar sobre los valores en nuestra lista con el iterador 
+// Podemos iterar sobre los valores en nuestra lista con el iterador
 // que definimos.
 for value in realList do write(value, ", ");
 writeln();
@@ -852,7 +851,7 @@ writeln();
 
 // Los módulos son la forma en que Chapel administra los espacios de nombres.
 // Los archivos que contienen estos módulos no necesitan ser nombrados después
-// de los módulos (como en Java), pero los archivos implícitamente nombran módulos. 
+// de los módulos (como en Java), pero los archivos implícitamente nombran módulos.
 // Por ejemplo, este archivo nombra implícitamente el módulo learnChapelInYMinutes
 
 module OurModule {
@@ -888,7 +887,7 @@ module OurModule {
 // Como OurModule usa Time, nosotros también usamos Time.
 use OurModule;
 
-// En este punto no hemos usado ChildModule o SiblingModule, por lo que sus símbolos 
+// En este punto no hemos usado ChildModule o SiblingModule, por lo que sus símbolos
 // (es decir, foo) no están disponibles para nosotros. Sin embargo, los nombres de
 // los módulos están disponibles y podemos llamar explícitamente a foo () a través de ellos.
 SiblingModule.foo();
@@ -901,7 +900,7 @@ foo();
 // Paralelismo
 
 // En otros idiomas, el paralelismo generalmente se realiza con librerias complicadas
-// y extrañas jerarquías de estructura de clases. 
+// y extrañas jerarquías de estructura de clases.
 // Chapel lo tiene directamente en el idioma.
 
 // Podemos declarar un procedimiento principal, pero todo el código anterior
@@ -909,7 +908,7 @@ foo();
 proc main() {
 
 // Una declaración de inicio hará girar el cuerpo de esa declaración en una nueva tarea.
-// Una declaración de sincronización garantizará que el progreso de la tarea principal 
+// Una declaración de sincronización garantizará que el progreso de la tarea principal
 // no avance hasta que los hijos hayan sincronizado nuevamente.
 
   sync {
@@ -927,15 +926,15 @@ proc main() {
   }
 
 // Una declaración de cobegin girará cada declaración del cuerpo en una nueva tarea.
-// Observe aquí que las impresiones de cada declaración pueden ocurrir en 
+// Observe aquí que las impresiones de cada declaración pueden ocurrir en
 // cualquier orden.
   cobegin {
     printFibb(20); // nueva tarea
     printFibb(10); // nueva tarea
     printFibb(5);  // nueva tarea
     {
-      // Este es un cuerpo de declaración anidado y, por lo tanto, es una 
+      // Este es un cuerpo de declaración anidado y, por lo tanto, es una
-      // declaración única para la declaración principal, ejecutada 
+      // declaración única para la declaración principal, ejecutada
       // por una sola tarea.
       writeln("esto se ");
       writeln("ejecuta");
@@ -943,29 +942,29 @@ proc main() {
     }
   }
 
-// Un bucle coforall creará una nueva tarea para CADA iteración. 
+// Un bucle coforall creará una nueva tarea para CADA iteración.
-// Nuevamente vemos que las impresiones suceden en cualquier orden. 
+// Nuevamente vemos que las impresiones suceden en cualquier orden.
-// NOTA: ¡coforall debe usarse solo para crear tareas! 
+// NOTA: ¡coforall debe usarse solo para crear tareas!
 // ¡Usarlo para iterar sobre una estructura es una muy mala idea!
   var num_tasks = 10; // Number of tasks we want
   coforall taskID in 1..#num_tasks {
     writeln("Hola de tarea# ", taskID);
   }
 
-// los bucles forall son otro bucle paralelo, pero solo crean un número 
+// los bucles forall son otro bucle paralelo, pero solo crean un número
 // menor de tareas, específicamente --dataParTasksPerLocale = número de tareas.
   forall i in 1..100 {
     write(i, ", ");
   }
   writeln();
 
-// Aquí vemos que hay secciones que están en orden, seguidas de una sección 
+// Aquí vemos que hay secciones que están en orden, seguidas de una sección
-// que no seguiría (por ejemplo, 1, 2, 3, 7, 8, 9, 4, 5, 6,). 
+// que no seguiría (por ejemplo, 1, 2, 3, 7, 8, 9, 4, 5, 6,).
 // Esto se debe a que cada tarea está asumiendo un fragmento del rango 1..10
-// (1..3, 4..6 o 7..9) haciendo ese fragmento en serie, pero cada tarea ocurre en paralelo. 
+// (1..3, 4..6 o 7..9) haciendo ese fragmento en serie, pero cada tarea ocurre en paralelo.
 // Sus resultados pueden depender de su máquina y configuración
 
-// Para los bucles forall y coforall, la ejecución de la tarea principal 
+// Para los bucles forall y coforall, la ejecución de la tarea principal
 // no continuará hasta que todos los hijos se sincronicen.
 
 // los bucles forall son particularmente útiles para la iteración paralela sobre matrices.
@@ -1002,7 +1001,7 @@ proc main() {
 
 // Las variables atómicas, comunes a muchos idiomas, son aquellas cuyas operaciones
 // ocurren sin interrupciones. Por lo tanto, varios subprocesos pueden modificar
-// las variables atómicas y pueden saber que sus valores son seguros. 
+// las variables atómicas y pueden saber que sus valores son seguros.
 // Las variables atómicas de la capilla pueden ser de tipo bool, int, uint y real.
   var uranium: atomic int;
   uranium.write(238);      // escribir atómicamente una variable
@@ -1041,7 +1040,7 @@ proc main() {
   }
 
 // las variables de sincronización tienen dos estados: vacío y lleno.
-// Si lee una variable vacía o escribe una variable completa, 
+// Si lee una variable vacía o escribe una variable completa,
 // se espera hasta que la variable esté llena o vacía nuevamente.
   var someSyncVar$: sync int; // varName$ Es una convención, no una ley.
   sync {
@@ -1058,7 +1057,7 @@ proc main() {
     }
   }
 
-// las variales individuales solo se pueden escribir una vez. 
+// las variales individuales solo se pueden escribir una vez.
 // Una lectura en un solo no escrito da como resultado una espera,
 // pero cuando la variable tiene un valor, puede leerse indefinidamente.
   var someSingleVar$: single int; // varName$ Es una convención, no una ley.
@@ -1078,7 +1077,7 @@ proc main() {
     }
   }
 
-// Aquí hay un ejemplo usando atómica y una variable de sincronización 
+// Aquí hay un ejemplo usando atómica y una variable de sincronización
 // para crear un mutex de cuenta regresiva
 //  (también conocido como multiplexor).
   var count: atomic int; // nuestro mostrador
@@ -1133,8 +1132,7 @@ proc main() {
 } // end main()
 ```
 
-¿Para quién es este tutorial?
+## ¿Para quién es este tutorial?
--------------------------
 
 Este tutorial es para personas que desean aprender las cuerdas de chapel sin tener
 que escuchar sobre qué mezcla de fibras son las cuerdas, o cómo fueron trenzadas,
@@ -1148,61 +1146,58 @@ para ver si se han agregado más temas o se han creado más tutoriales.
 
 ### Lo que le falta a este tutorial:
 
- * Exposición de los [módulos estándar](https://chapel-lang.org/docs/latest/modules/standard.html)
+* Exposición de los [módulos estándar](https://chapel-lang.org/docs/latest/modules/standard.html)
- * Múltiples configuraciones regionales (sistema de memoria distribuida)
+* Múltiples configuraciones regionales (sistema de memoria distribuida)
- * Registros
+* Registros
- * Iteradores paralelos
+* Iteradores paralelos
 
-¡Sus comentarios, preguntas y descubrimientos son importantes para los desarrolladores!
+## ¡Sus comentarios, preguntas y descubrimientos son importantes para los desarrolladores!
------------------------------------------------------------------------
 
-El lenguaje Chapel todavía está en desarrollo activo, por lo que 
+El lenguaje Chapel todavía está en desarrollo activo, por lo que
-ocasionalmente hay problemas con el rendimiento y 
+ocasionalmente hay problemas con el rendimiento y
 las características del lenguaje.
 
-Cuanta más información brinde al equipo de desarrollo de Chapel 
+Cuanta más información brinde al equipo de desarrollo de Chapel
-sobre los problemas que encuentre o las características que le gustaría ver, 
+sobre los problemas que encuentre o las características que le gustaría ver,
 mejor será el lenguaje.
 
-
 Hay varias formas de interactuar con los desarrolladores:
-+ [Chat de Gitter](https://gitter.im/chapel-lang/chapel)
+
-+ [lista de emails de Sourceforge](https://sourceforge.net/p/chapel/mailman)
+* [Chat de Gitter](https://gitter.im/chapel-lang/chapel)
+* [lista de emails de Sourceforge](https://sourceforge.net/p/chapel/mailman)
 
 Si está realmente interesado en el desarrollo del compilador o en contribuir al proyecto,
 [consulte el repositorio maestro de GitHub](https://github.com/chapel-lang/chapel).
 Está bajo el [La licencia Apache 2.0](http://www.apache.org/licenses/LICENSE-2.0).
 
-Instalar el compilador
+## Instalar el compilador
------------------------
 
 [La documentación oficial de Chapel detalla cómo descargar y compilar el compilador de Chapel.](https://chapel-lang.org/docs/usingchapel/QUICKSTART.html)
 
-Chapel se puede construir e instalar en su máquina promedio 'nix (y cygwin). 
+Chapel se puede construir e instalar en su máquina promedio 'nix (y cygwin).
 [Descargue la última versión de lanzamiento](https://github.com/chapel-lang/chapel/releases/)
 y es tan fácil como
 
- 1. `tar -xvf chapel-<VERSION>.tar.gz`
+1. `tar -xvf chapel-<VERSION>.tar.gz`
- 2. `cd chapel-<VERSION>`
+2. `cd chapel-<VERSION>`
- 3. `source util/setchplenv.bash # or .sh or .csh or .fish`
+3. `source util/setchplenv.bash # or .sh or .csh or .fish`
- 4. `make`
+4. `make`
- 5. `make check # optional`
+5. `make check # optional`
 
 You will need to `source util/setchplenv.EXT` from within the Chapel directory
 (`$CHPL_HOME`) every time your terminal starts so it's suggested that you drop
 that command in a script that will get executed on startup (like .bashrc).
 
 Necesitará `source util/setchplenv.EXT` desde el directorio de Chapel (`$CHPL_HOME`)
-cada vez que se inicie su terminal, por lo que se sugiere que suelte ese comando 
+cada vez que se inicie su terminal, por lo que se sugiere que suelte ese comando
 en un script que se ejecutará al inicio (como .bashrc).
 
 Chapel se instala fácilmente con Brew para OS X
 
- 1. `brew update`
+1. `brew update`
- 2. `brew install chapel`
+2. `brew install chapel`
 
-Compilando Código
+## Compilando Código
---------------
 
 Construye como otros compiladores:
 
@@ -1210,10 +1205,10 @@ Construye como otros compiladores:
 
 Argumentos notables:
 
- * `--fast`: habilita varias optimizaciones y deshabilita las comprobaciones 
+* `--fast`: habilita varias optimizaciones y deshabilita las comprobaciones
- de los límites de la matriz Solo debe habilitarse cuando la aplicación es estable.
+  de los límites de la matriz Solo debe habilitarse cuando la aplicación es estable.
- * `--set <Nombre del Symbolo>=<Valor>`: establece el param de configuracion 
+* `--set <Nombre del Symbolo>=<Valor>`: establece el param de configuracion
- `<Nombre del Symbolo>` a `<Valor>`en tiempo de compilación.
+  `<Nombre del Symbolo>` a `<Valor>`en tiempo de compilación.
- * `--main-module <Nombre del módulo>`: use el procedimiento main() que se encuentra en el módulo
+* `--main-module <Nombre del módulo>`: use el procedimiento main() que se encuentra en el módulo
-    `<Nombre del módulo>` como principal del ejecutable.
+  `<Nombre del módulo>` como principal del ejecutable.
- * `--module-dir <Directorio>`: incluye `<Directorio>` en la ruta de búsqueda del módulo.
+* `--module-dir <Directorio>`: incluye `<Directorio>` en la ruta de búsqueda del módulo.

pt-br/cypher-pt.html.markdown

@@ -6,14 +6,11 @@ contributors:
 
 lang: pt-br
 ---
-
 O Cypher é a linguagem de consulta do Neo4j para manipular gráficos facilmente. Ela reutiliza a sintaxe do SQL e a mistura com o tipo de ascii-art para representar gráficos. Este tutorial pressupõe que você já conheça conceitos de gráficos como nós e relacionamentos.
 
 [Leia mais aqui.](https://neo4j.com/developer/cypher-query-language/)
 
-
+## Nós
-Nós
----
 
 **Representa um registro em um gráfico.**
 
@@ -34,21 +31,19 @@ Um nó pode ter algumas *propriedades*, aqui **name** e **age**. Começa com min
 
 Os tipos permitidos nas propriedades:
 
- - Numeric
+- Numeric
- - Boolean
+- Boolean
- - String
+- String
- - Lista de tipos primitivos anteriores
+- Lista de tipos primitivos anteriores
 
 *Aviso: não há propriedade datetime no Cypher! Você pode usar String com um padrão específico ou um Numeric a partir de uma data específica.*
 
 `p.name`
 Você pode acessar uma propriedade com o estilo de ponto.
 
+## Relacionamentos (ou Arestas)
 
-Relacionamentos (ou Arestas)
+**Conecta dois nós.**
----
-
-**Conecta dois nós**
 
 `[:KNOWS]`
 É um *relacionamento* com o *label* **KNOWS**. É um *label* como um rótulo do nó. Começa com maiúsculas e usa UPPER_SNAKE_CASE.
@@ -62,9 +57,7 @@ O mesmo *relacionamento*, com *propriedades* (como *nó*), aqui **since**.
 `[k:KNOWS*..4]`
 É uma informação estrutural para usar em um *path* (visto posteriormente). Aqui, **\*..4** diz, “Corresponda o padrão, com a relação **k** que é repetida de 1 a 4 vezes.
 
-
+## Paths
-Paths
----
 
 **A maneira de misturar nós e relacionamentos.**
 
@@ -80,9 +73,9 @@ 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
 (user)-[:KNOWS]-(friend)-[:KNOWS]-(foaf)
 
@@ -96,13 +89,11 @@ path = shortestPath( (user)-[:KNOWS*..5]-(other) )
 (root)<-[:PARENT*]-(leaf:Category)-[:ITEM]->(data:Product)
 ```
 
-
+## Crie consultas
-Crie consultas
----
 
 Crie um novo nó
 
-```
+```cypher
 CREATE (a:Person {name:"Théo Gauchoux"})
 RETURN a
 ```
@@ -111,52 +102,51 @@ RETURN a
 
 Crie um novo relacionamento (com 2 novos nós)
 
-```
+```cypher
 CREATE (a:Person)-[k:KNOWS]-(b:Person)
 RETURN a,k,b
 ```
 
-Consultas que casam
+## Consultas que casam
----
 
 Casam todos os nós
 
-```
+```cypher
 MATCH (n)
 RETURN n
 ```
 
 Casam nós por label
 
-```
+```cypher
 MATCH (a:Person)
 RETURN a
 ```
 
 Casam nós por label e propriedade
 
-```
+```cypher
 MATCH (a:Person {name:"Théo Gauchoux"})
 RETURN a
 ```
 
 Casam nós de acordo com os relacionamentos (não direcionados)
 
-```
+```cypher
 MATCH (a)-[:KNOWS]-(b)
 RETURN a,b
 ```
 
 Casam nós de acordo com os relacionamentos (direcionados)
 
-```
+```cypher
 MATCH (a)-[:MANAGES]->(b)
 RETURN a,b
 ```
 
 Casam nós com um cláusula `WHERE`
 
-```
+```cypher
 MATCH (p:Person {name:"Théo Gauchoux"})-[s:LIVES_IN]->(city:City)
 WHERE s.since = 2015
 RETURN p,state
@@ -164,19 +154,17 @@ RETURN p,state
 
 Você pode usa a cláusula `MATCH WHERE` com a cláusula `CREATE`
 
-```
+```cypher
 MATCH (a), (b)
 WHERE a.name = "Jacquie" AND b.name = "Michel"
 CREATE (a)-[:KNOWS]-(b)
 ```
 
-
+## Atualizar consultas
-Atualizar consultas
----
 
 Atualizar uma propriedade específica de um nó
 
-```
+```cypher
 MATCH (p:Person)
 WHERE p.name = "Théo Gauchoux"
 SET p.age = 23
@@ -184,7 +172,7 @@ SET p.age = 23
 
 Substituir todas as propriedades de um nó
 
-```
+```cypher
 MATCH (p:Person)
 WHERE p.name = "Théo Gauchoux"
 SET p = {name: "Michel", age: 23}
@@ -192,7 +180,7 @@ SET p = {name: "Michel", age: 23}
 
 Adicionar nova propriedade a um nó
 
-```
+```cypher
 MATCH (p:Person)
 WHERE p.name = "Théo Gauchoux"
 SET p + = {studies: "IT Engineering"}
@@ -200,19 +188,17 @@ SET p + = {studies: "IT Engineering"}
 
 Adicione um label a um nó
 
-```
+```cypher
 MATCH (p:Person)
 WHERE p.name = "Théo Gauchoux"
 SET p:Internship
 ```
 
-
+## Excluir consultas
-Excluir consultas
----
 
 Excluir um nó específico (os relacionamentos vinculados devem ser excluídos antes)
 
-```
+```cypher
 MATCH (p:Person)-[relationship]-()
 WHERE p.name = "Théo Gauchoux"
 DELETE relationship, p
@@ -220,7 +206,7 @@ DELETE relationship, p
 
 Remover uma propriedade em um nó específico
 
-```
+```cypher
 MATCH (p:Person)
 WHERE p.name = "Théo Gauchoux"
 REMOVE p.age
@@ -230,7 +216,7 @@ REMOVE p.age
 
 Remover um label de um nó específico
 
-```
+```cypher
 MATCH (p:Person)
 WHERE p.name = "Théo Gauchoux"
 DELETE p:Person
@@ -238,7 +224,7 @@ DELETE p:Person
 
 Excluir o banco de dados inteiro
 
-```
+```cypher
 MATCH (n)
 OPTIONAL MATCH (n)-[r]-()
 DELETE n, r
@@ -246,9 +232,7 @@ DELETE n, r
 
 *Sério, é o `rm -rf /` do Cypher !*
 
-
+## Outras cláusulas úteis
-Outras cláusulas úteis
----
 
 `PROFILE`
 Antes de uma consulta, mostre o plano de execução dela.
@@ -259,9 +243,7 @@ Contar entidades (nós ou relacionamentos) que casam com **e**.
 `LIMIT x`
 Limite o resultado aos primeiros x resultados.
 
-
+## Dicas Especiais
-Dicas Especiais
----
 
 - Há apenas comentários de uma linha no Cypher, com barras duplas : // Comentários
 - Você pode executar um script Cypher armazenado em um arquivo **.cql** diretamente no Neo4j (é uma importação). No entanto, você não pode ter várias instruções neste arquivo (separadas por **;**).

uk-ua/cypher-ua.html.markdown

@@ -13,11 +13,9 @@ Cypher - це мова запитів Neo4j для спрощення робот
 
 [Деталі тут](https://neo4j.com/developer/cypher-query-language/)
 
+## Вершини
 
-Вершини
+#### Відображує запис у графі
----
-
-**Відображує запис у графі.**
 
 `()`
 Таким чином у запиті позначається пуста *вершина*. Використовується зазвичай для того, щоб позначити, що вона є, проте це не так вже й важливо для запиту.
@@ -36,27 +34,24 @@ Cypher - це мова запитів Neo4j для спрощення робот
 
 Наступні типи дозволяється використовувати у властивостях:
 
- - Чиселиний
+- Чиселиний
- - Булевий
+- Булевий
- - Рядок
+- Рядок
- - Списки попередніх примітивних типів
+- Списки попередніх примітивних типів
 
 *Увага! В Cypher не існує типу, що відображає час. Замість нього можна використовувати рядок із визначеним шаблоном або чисельне відображення певної дати.*
 
 `p.name`
 За допомогою крапки можна звернутись до властивості вершини.
 
-
+## Зв'язки (або ребра)
-Зв'язки (або ребра)
+#### Сполучають дві вершини
----
-
-**Сполучають дві вершини**
 
 `[:KNOWS]`
 Це *зв'язок* з *ярликом* **KNOWS**. Це такий же самий *ярлик* як і у вершини. Починається з великої літери та використовує ВЕРХНІЙ\_РЕГІСТР\_ІЗ\_ЗМІЇНОЮ\_НОТАЦІЄЮ.
 
 `[k:KNOWS]`
-Це той же самий *зв'язок*, до якого можна звертатись через змінну **k**. Можна подалі використовувати у запиті, хоч це і не обов'язково. 
+Це той же самий *зв'язок*, до якого можна звертатись через змінну **k**. Можна подалі використовувати у запиті, хоч це і не обов'язково.
 
 `[k:KNOWS {since:2017}]`
 Той же *зв'язок*, але вже із *властивостями* (як у *вершини*), в данному випадку властивість - це  **since**.
@@ -64,11 +59,8 @@ Cypher - це мова запитів Neo4j для спрощення робот
 `[k:KNOWS*..4]`
 Це структурна інформація, яку використовують *шляхи*, які розглянуті нижче. В данному випадку, **\*..4** говорить: "Сумістити шаблон із зв'язком **k**, що повторюватиметься від одного до чотирьох разів."
 
-
+## Шляхи
-Шляхи
+#### Спосіб поєднувати вершини та зв'язки.
----
-
-**Спосіб поєднувати вершини та зв'язки.**
 
 `(a:Person)-[:KNOWS]-(b:Person)`
 Шлях описує, що вершини **a** та **b** знають (knows) один одного.
@@ -84,8 +76,8 @@ Cypher - це мова запитів Neo4j для спрощення робот
 
 Шаблони, які часто використовуються (з документації Neo4j):
 
-```
+```cypher
-// Друг-мого-друга 
+// Друг-мого-друга
 (user)-[:KNOWS]-(friend)-[:KNOWS]-(foaf)
 
 // Найкоротший шлях
@@ -98,13 +90,11 @@ path = shortestPath( (user)-[:KNOWS*..5]-(other) )
 (root)<-[:PARENT*]-(leaf:Category)-[:ITEM]->(data:Product)
 ```
 
-
+## Запити на створення
-Запити на створення
----
 
 Створити нову вершину:
 
-```
+```cypher
 CREATE (a:Person {name:"Théo Gauchoux"})
 RETURN a
 ```
@@ -113,52 +103,51 @@ RETURN a
 
 Створити новий зв'язок (із двома вершинами):
 
-```
+```cypher
 CREATE (a:Person)-[k:KNOWS]-(b:Person)
 RETURN a,k,b
 ```
 
-Запити на знаходження
+## Запити на знаходження
----
 
 Знайти всі вершини:
 
-```
+```cypher
 MATCH (n)
 RETURN n
 ```
 
 Знайти вершини за ярликом:
 
-```
+```cypher
 MATCH (a:Person)
 RETURN a
 ```
 
 Знайти вершини за ярликом та властивістю:
 
-```
+```cypher
 MATCH (a:Person {name:"Théo Gauchoux"})
 RETURN a
 ```
 
 Знайти вершини відповідно до зв'язків (ненаправлених):
 
-```
+```cypher
 MATCH (a)-[:KNOWS]-(b)
 RETURN a,b
 ```
 
 Знайти вершини відповідно до зв'язків (направлених):
 
-```
+```cypher
 MATCH (a)-[:MANAGES]->(b)
 RETURN a,b
 ```
 
 Знайти вершини за допомогою `WHERE`:
 
-```
+```cypher
 MATCH (p:Person {name:"Théo Gauchoux"})-[s:LIVES_IN]->(city:City)
 WHERE s.since = 2015
 RETURN p,state
@@ -166,19 +155,17 @@ RETURN p,state
 
 Можна використовувати вираз `MATCH WHERE` разом із операцією `CREATE`:
 
-```
+```cypher
 MATCH (a), (b)
 WHERE a.name = "Jacquie" AND b.name = "Michel"
 CREATE (a)-[:KNOWS]-(b)
 ```
 
-
+## Запити на оновлення
-Запити на оновлення
----
 
 Оновити окрему властивість вершини:
 
-```
+```cypher
 MATCH (p:Person)
 WHERE p.name = "Théo Gauchoux"
 SET p.age = 23
@@ -186,7 +173,7 @@ SET p.age = 23
 
 Оновити всі властивості вершини:
 
-```
+```cypher
 MATCH (p:Person)
 WHERE p.name = "Théo Gauchoux"
 SET p = {name: "Michel", age: 23}
@@ -194,7 +181,7 @@ SET p = {name: "Michel", age: 23}
 
 Додати нову властивіcть до вершини:
 
-```
+```cypher
 MATCH (p:Person)
 WHERE p.name = "Théo Gauchoux"
 SET p + = {studies: "IT Engineering"}
@@ -202,19 +189,17 @@ SET p + = {studies: "IT Engineering"}
 
 Повісити ярлик на вершину:
 
-```
+```cypher
 MATCH (p:Person)
 WHERE p.name = "Théo Gauchoux"
 SET p:Internship
 ```
 
-
+## Запити на видалення
-Запити на видалення
----
 
 Видалити окрему вершину (пов'язані ребра повинні бути видалені перед цим):
 
-```
+```cypher
 MATCH (p:Person)-[relationship]-()
 WHERE p.name = "Théo Gauchoux"
 DELETE relationship, p
@@ -222,7 +207,7 @@ DELETE relationship, p
 
 Видалити властивість певної вершини:
 
-```
+```cypher
 MATCH (p:Person)
 WHERE p.name = "Théo Gauchoux"
 REMOVE p.age
@@ -230,17 +215,17 @@ REMOVE p.age
 
 *Зверніть увагу, що ключове слово `REMOVE` це не те саме, що й  `DELETE`!*
 
-Видалити ярлик певної вершини: 
+Видалити ярлик певної вершини:
 
-```
+```cypher
 MATCH (p:Person)
 WHERE p.name = "Théo Gauchoux"
 DELETE p:Person
 ```
 
-Видалити всю базу даних: 
+Видалити всю базу даних:
 
-```
+```cypher
 MATCH (n)
 OPTIONAL MATCH (n)-[r]-()
 DELETE n, r
@@ -248,9 +233,7 @@ DELETE n, r
 
 *Так, це `rm -rf /` на мові Cypher !*
 
-
+## Інші корисні запити
-Інші корисні запити
----
 
 `PROFILE`
 Перед виконанням, показати план виконання запитів.
@@ -261,11 +244,9 @@ DELETE n, r
 `LIMIT x`
 Обмежити результат до x перших результатів.
 
+## Особливі підказки
 
-Особливі підказки
+- У мові Cypher існують лише однорядкові коментарі, що позначаються двійним слешем : `// Коментар`
----
-
-- У мові Cypher існують лише однорядкові коментарі, що позначаються двійним слешем : // Коментар
 - Можна виконати скрипт Cypher, збережений у файлі **.cql** прямо в Neo4j (прямо як імпорт). Проте, не можна мати мати кілька виразів в цьому файлі (розділених **;**).
 - Використовуйте командний рядок Neo4j для написання запитів Cypher, це легко і швидко.
 - Cypher планує бути стандартною мовою запитів для всіх графових баз даних (більш відома як  **OpenCypher**).