Merge branch 'master' into MarkdownFRChanges

10 files changed, 953 insertions, 25 deletions

diff --git a/es-es/awk-es.html.markdown b/es-es/awk-es.html.markdown
index 307ba817..0516ea92 100644
--- a/es-es/awk-es.html.markdown
+++ b/es-es/awk-es.html.markdown
@@ -166,7 +166,7 @@ function arithmetic_functions(a, b, c,     localvar) {
     # trigonométricas estándar
     localvar = sin(a)
     localvar = cos(a)
-    localvar = atan2(a, b) # arcotangente de b / a
+    localvar = atan2(b, a) # arcotangente de b / a
 
     # Y cosas logarítmicas
     localvar = exp(a)
diff --git a/es-es/c++-es.html.markdown b/es-es/c++-es.html.markdown
index bd1ad07c..2c3762d5 100644
--- a/es-es/c++-es.html.markdown
+++ b/es-es/c++-es.html.markdown
@@ -823,7 +823,6 @@ v.swap(vector<Foo>());
 ```
 Otras lecturas:
 
-Una referencia del lenguaje hasta a la fecha se puede encontrar en
-<http://cppreference.com/w/cpp>
-
-Recursos adicionales se pueden encontrar en <http://cplusplus.com>
+* Una referencia del lenguaje hasta a la fecha se puede encontrar en [CPP Reference](http://cppreference.com/w/cpp).
+* Recursos adicionales se pueden encontrar en [[CPlusPlus]](http://cplusplus.com).
+* Un tutorial que cubre los conceptos básicos del lenguaje y la configuración del entorno de codificación está disponible en [TheChernoProject - C ++](https://www.youtube.com/playlist?list=PLlrATfBNZ98dudnM48yfGUldqGD0S4FF).
diff --git a/es-es/csharp-es.html.markdown b/es-es/csharp-es.html.markdown
index 5d730497..72a0f90c 100644
--- a/es-es/csharp-es.html.markdown
+++ b/es-es/csharp-es.html.markdown
@@ -5,7 +5,7 @@ contributors:
     - ["Irfan Charania", "https://github.com/irfancharania"]
     - ["Max Yankov", "https://github.com/golergka"]
 translators:
-    - ["Olfran Jiménez", "https://twitter.com/neslux"]	
+    - ["Olfran Jiménez", "https://twitter.com/neslux"]
 lang: es-es
 
 ---
diff --git a/es-es/erlang-es.html.markdown b/es-es/erlang-es.html.markdown
new file mode 100644
index 00000000..bc6317a5
--- /dev/null
+++ b/es-es/erlang-es.html.markdown
@@ -0,0 +1,293 @@
+---
+language: erlang
+lang: es-es
+contributors:
+    - ["Giovanni Cappellotto", "http://www.focustheweb.com/"]
+translators:
+  - ["Ernesto Pelayo", "http://github.com/ErnestoPelayo"]
+filename: learnerlang-es.erl
+---
+
+# Erlang
+%  Signo de porcentaje inicia un comentario de una línea.
+
+%% Se usarán dos por ciento de caracteres para comentar funciones.
+
+%%% Se usarán tres por ciento de caracteres para comentar los módulos.
+
+### Utilizamos tres tipos de puntuación en Erlang.
+
++ **Comas (`,`)**  argumentos separados en llamadas a funciones, constructores de
+datos y patrones.
+
++ **Periodos (`.`)** (seguido de espacios en blanco) separa funciones completas y
+expresiones en el shell.
+
++  **Semicolons (`;`)** cláusulas separadas. Encontramos cláusulas en varios contextos: de definiciones de funciones y en **`case`**,**` if`**, **`try..catch`**, y **` receive`** de expresiones.
+
+ ## 1.-Variables y coincidencia de patrones.
+
+
+- En Erlang, las nuevas variables están vinculadas con una instrucción **`=`**.
+>**Num = 42.**
+
+- Todos los nombres de variables deben comenzar con una letra mayúscula.
+
+- Erlang tiene variables de asignación única; si intentas asignar un diferente de valor a la variable **`Num`**, obtendrá un error.
+Num = 43. **error de excepción**: no coincide con el valor del lado derecho 43
+
+- En la mayoría de los idiomas, **`=`** denota una declaración de asignación. En Erlang, sin embargo,**`=`** denota una operación de coincidencia de patrones.
+
+- Cuando se usa una variable vacía en el del lado izquierdo del operador `=` to está vinculado (asignado), pero cuando está atado variable se usa en el lado izquierdo, se observa el siguiente comportamiento.
+>**`Lhs = Rhs`** realmente significa esto: evaluar el lado derecho (**` Rhs`**),  y luego coincide con el resultado contra el patrón en el lado izquierdo (**`Lhs`**).
+>**Num = 7 * 6.**
+
+- Número de punto flotante.
+Pi = 3.14159.
+
+- Los átomos se usan para representar diferentes valores constantes no numéricos.
+
+- Átomos comienza con letras minúsculas, seguido de una secuencia de caracteres
+
+- alfanuméricos de caracteres o el signo de subrayado (**`_`**) o en (**` @ `**).
+>**Hola = hola.**
+  **OtherNode = ejemplo @ nodo.**
+
+- Los átomos con valores no alfanuméricos se pueden escribir al encerrar los átomos con apóstrofes.
+>**AtomWithSpace = 'algún átomo con espacio'.**
+
++ Tuples son similares a las estructuras en C.
+>**Point = {point, 10, 45}.**
+
+- Si queremos extraer algunos valores de una tupla, usamos el patrón de coincidencia
+ operador **`=`**.
+> **{punto, X, Y} = Punto. % X = 10, Y = 45**
+
+- Podemos usar **`_`** como marcador de posición para variables que no nos interesan.
+
+- El símbolo **`_`** se llama una variable anónima. A diferencia de las variables  regulares,varias apariciones de `_` en el mismo patrón no tienen que vincularse a mismo valor.
+>**Person = {person, {name, {first, joe}, {last, armstrong}}, {footsize, 42}}.**
+**{_, {_, {_, who }, _}, _} = Persona. % Who = joe**
+
++ Creamos una lista al encerrar los elementos de la lista entre corchetes y separándolos con comas.
+
++ Los elementos individuales de una lista pueden ser de cualquier tipo.
+
+- El primer elemento de una lista es el encabezado de la lista. Si te imaginas eliminar del encabezado de la lista, lo que queda se llama cola de la lista.
+>**ThingsToBuy = [{manzanas, 10}, {peras, 6}, {leche, 3}].**
+
+- Si `T` es una lista, entonces **` [H | T] `** también es una lista, con la cabeza **` H`** y la cola **`T`**.
+
++ La barra vertical (**`|`**) separa el encabezado de una lista de su cola.
+  **`[]`** es la lista vacía.
+
++ Podemos extraer elementos de una lista con una operación de coincidencia de
+  patrones. Si nosotros tiene una lista no vacía **`L`**, luego la expresión **` [X | Y] = L`**, donde **`X`** y **` Y`** son variables independientes, extraerán el encabezado de la lista en **`X`** y la cola de la lista en **`Y`**.
+>**[FirstThing | OtherThingsToBuy] = ThingsToBuy.**
+**FirstThing = {manzanas, 10}**
+**OtherThingsToBuy = [{peras, 6}, {leche, 3}]**
+
++ No hay cadenas en Erlang. Las cadenas son realmente solo listas de enteros.
+
++ Las cadenas están entre comillas dobles (**`" `**).
+>**Nombre = "Hola".
+[72, 101, 108, 108, 111] = "Hola".**
+
+##  2. Programación secuencial.
+
+
+- Los módulos son la unidad básica de código en Erlang. Todas las funciones que escribimos son almacenado en módulos.
+
+- Los módulos se almacenan en archivos con extensiones **`.erl`**.
+- Los módulos deben compilarse antes de poder ejecutar el código. Un módulo compilado tiene el extensión **`.beam`**.
+>**-módulo (geometría).
+-export ([area / 1]).  de la lista de funciones exportadas desde el módulo.**
+
++ La función **`área`** consta de dos cláusulas. Las cláusulas están separadas por un punto y coma, y ​​la cláusula final termina con punto-espacio en blanco. Cada cláusula tiene una cabeza y un cuerpo; la cabeza consiste en un nombre de función seguido de un patrón (entre paréntesis), y el cuerpo consiste en una secuencia de expresiones, que se evalúan si el patrón en la cabeza es exitoso coincide con los argumentos de llamada. Los patrones se combinan en el orden aparecen en la definición de la función.
+>**área ({rectángulo, ancho, Ht}) -> ancho * Ht;
+área ({círculo, R}) -> 3.14159 * R * R** .
+
+ ### Compila el código en el archivo geometry.erl.
+c (geometría).  {ok, geometría}
+
++ Necesitamos incluir el nombre del módulo junto con el nombre de la función para identifica exactamente qué función queremos llamar.
+>**geometría: área ({rectángulo, 10, 5}). % 50**
+**geometría: área ({círculo, 1.4}). % 6.15752**
+
++ En Erlang, dos funciones con el mismo nombre y arity diferente (número de argumentos) en el mismo módulo representan funciones completamente diferentes.
+>-**module (lib_misc)**.
+-**export ([sum / 1])**.  
+
+- función de exportación **`suma`** de arity 1  acepta un argumento:
+>**lista de enteros.
+suma (L) -> suma (L, 0).
+suma ([], N) -> N;
+suma ([H | T], N) -> suma (T, H + N).**
++ Funs son funciones **"anónimas"**. Se llaman así porque tienen sin nombre. Sin embargo, pueden asignarse a variables.
+Doble = diversión (X) -> 2 * X final.  **`Doble`** apunta a una función anónima con el controlador: **#Fun <erl_eval.6.17052888>
+Doble (2). % 4**
+
+- Functions acepta funs como sus argumentos y puede devolver funs.
+>**Mult = diversión (Times) -> (fun (X) -> X * Times end) end.
+Triple = Mult (3).
+Triple (5). % 15**
+
+- Las listas de comprensión son expresiones que crean listas sin tener que usar
+ funs, mapas o filtros.
+ - La notación **`[F (X) || X <- L] `** significa" la lista de **`F (X)`** donde se toma **`X`**% de la lista **`L`."**
+>**L = [1,2,3,4,5].
+[2 * X || X <- L]. % [2,4,6,8,10]**
+
+- Una lista de comprensión puede tener generadores y filtros, que seleccionan un subconjunto de los valores generados
+>**EvenNumbers = [N || N <- [1, 2, 3, 4], N rem 2 == 0]. % [2, 4]**
+
+- Los protectores son construcciones que podemos usar para aumentar el poder del patrón coincidencia. Usando guardias, podemos realizar pruebas simples y comparaciones en el de variables en un patrón.
+Puede usar guardias en la cabeza de las definiciones de funciones donde están introducido por la palabra clave **`when`**, o puede usarlos en cualquier lugar del lenguaje donde se permite una expresión.
+>**max (X, Y) cuando X> Y -> X;
+max (X, Y) -> Y.**
+
+- Un guardia es una serie de expresiones de guardia, separadas por comas (**`,`**).
+- La guardia **`GuardExpr1, GuardExpr2, ..., GuardExprN`** es verdadera si todos los guardias expresiones **`GuardExpr1`,` GuardExpr2`, ..., `GuardExprN`** evalúan **`true`**.
+>**is_cat (A) cuando is_atom (A), A =: = cat -> true;
+is_cat (A) -> false.
+is_dog (A) cuando is_atom (A), A =: = dog -> true;
+is_dog (A) -> false.**
+
+No nos detendremos en el operador **`=: =`** aquí; Solo tenga en cuenta que está acostumbrado a comprueba si dos expresiones de Erlang tienen el mismo valor * y * del mismo tipo. Contrasta este comportamiento con el del operador **`==`**:
+
+>**1 + 2 =: = 3.% true
+1 + 2 =: = 3.0. % false
+1 + 2 == 3.0. % true**
+
+ Una secuencia de guardia es una guardia individual o una serie de guardias, separadas por punto y coma (**`;`**). La secuencia de guardia **`G1; G2; ...; Gn`** es verdadero si en menos uno de los guardias **`G1`,` G2`, ..., `Gn`** se evalúa como **` true`**.
+>**is_pet (A) cuando is_atom (A), (A =: = dog); (A =: = cat) -> true;
+is_pet (A) -> false.**
+
+- **Advertencia**: no todas las expresiones de Erlang válidas se pueden usar como expresiones de guarda; en particular, nuestras funciones **`is_cat`** y **`is_dog`** no se pueden usar dentro del secuencia de protección en la definición de **`is_pet`**. Para una descripción de expresiones permitidas en secuencias de guarda, consulte la sección específica en el manual de referencia de Erlang:
+### http://erlang.org/doc/reference_manual/expressions.html#guards
+
+- Los registros proporcionan un método para asociar un nombre con un elemento particular en un de tupla De las definiciones de registros se pueden incluir en los archivos de código fuente de Erlang o poner en archivos con la extensión **`.hrl`**, que luego están incluidos en el código fuente de Erlang de archivos.
+
+>**-record (todo, {
+  status = recordatorio,% valor predeterminado
+  quien = joe,
+  texto
+}).**
+
+- Tenemos que leer las definiciones de registro en el shell antes de que podamos definir un
+ de registro. Usamos la función shell **`rr`** (abreviatura de los registros de lectura) para hacer esto.
+
+>**rr ("records.hrl").** % [que hacer]
+
+- **Creando y actualizando registros:**
+>**X = #todo {}.
+% #todo {status = recordatorio, who = joe, text = undefined}
+X1 = #todo {estado = urgente, texto = "Corregir errata en el libro"}.
+% #todo {status = urgent, who = joe, text = "Corregir errata en el libro"}
+X2 = X1 # todo {estado = hecho}.
+% #todo {status = done, who = joe, text = "Corregir errata en el libro"}
+expresiones `case`**.
+
+**`filter`** devuelve una lista de todos los elementos **` X`** en una lista **`L`** para la cual **` P (X) `** es true.
+>**filter(P, [H|T]) ->
+  case P(H) of
+    true -> [H|filter(P, T)];
+    false -> filter(P, T)
+  end;
+filter(P, []) -> [].
+filter(fun(X) -> X rem 2 == 0 end, [1, 2, 3, 4]). % [2, 4]**
+
+expresiones **`if`**.
+>**max(X, Y) ->
+  if
+    X > Y -> X;
+    X < Y -> Y;
+    true -> nil
+  end.**
+
+**Advertencia:** al menos uno de los guardias en la expresión **`if`** debe evaluar a **`true`**; de lo contrario, se generará una excepción.
+
+## 3. Excepciones.
+
+
+- El sistema genera excepciones cuando se encuentran errores internos o explícitamente en el código llamando **`throw (Exception)`**, **`exit (Exception)`**, o **`erlang: error (Exception)`**.
+>**generate_exception (1) -> a;
+generate_exception (2) -> throw (a);
+generate_exception (3) -> exit (a);
+generate_exception (4) -> {'EXIT', a};
+generate_exception (5) -> erlang: error (a).**
+
+- Erlang tiene dos métodos para atrapar una excepción. Una es encerrar la llamada a de la función que genera la excepción dentro de una expresión **`try ... catch`**.
+>**receptor (N) ->
+  prueba generar_excepción (N) de
+    Val -> {N, normal, Val}
+  captura
+    throw: X -> {N, atrapado, arrojado, X};
+    exit: X -> {N, atrapado, salido, X};
+    error: X -> {N, atrapado, error, X}
+  end.**
+
+- El otro es encerrar la llamada en una expresión **`catch`**. Cuando atrapas un de excepción, se convierte en una tupla que describe el error.
+>**catcher (N) -> catch generate_exception (N).**
+
+## 4. Concurrencia
+
+- Erlang se basa en el modelo de actor para concurrencia. Todo lo que necesitamos para escribir de programas simultáneos en Erlang son tres primitivos: procesos de desove, de envío de mensajes y recepción de mensajes.
+
+- Para comenzar un nuevo proceso, usamos la función **`spawn`**, que toma una función como argumento.
+
+>**F = diversión () -> 2 + 2 final. % #Fun <erl_eval.20.67289768>
+spawn (F). % <0.44.0>**
+
+- **`spawn`** devuelve un pid (identificador de proceso); puedes usar este pid para enviar de mensajes al proceso. Para pasar mensajes, usamos el operador **`!`**.
+
+- Para que todo esto sea útil, debemos poder recibir mensajes. Esto es logrado con el mecanismo **`receive`**:
+
+>**-module (calcular Geometría).
+-compile (export_all).
+calculateArea () ->
+    recibir
+      {rectángulo, W, H} ->
+        W * H;
+      {circle, R} ->
+        3.14 * R * R;
+      _ ->
+        io: format ("Solo podemos calcular el área de rectángulos o círculos")
+    end.**
+
+- Compile el módulo y cree un proceso que evalúe **`calculateArea`** en cáscara.
+>**c (calcular Geometría).
+CalculateArea = spawn (calcular Geometría, calcular Área, []).
+CalculateArea! {círculo, 2}. % 12.56000000000000049738**
+
+- El shell también es un proceso; puedes usar **`self`** para obtener el pid actual.
+**self(). % <0.41.0>**
+
+## 5. Prueba con EUnit
+
+- Las pruebas unitarias se pueden escribir utilizando los generadores de prueba de EUnits y afirmar macros
+>**-módulo (fib).
+-export ([fib / 1]).
+-include_lib ("eunit / include / eunit.hrl").**
+
+>**fib (0) -> 1;
+fib (1) -> 1;
+fib (N) when N> 1 -> fib (N-1) + fib (N-2).**
+
+>**fib_test_ () ->
+    [? _assert (fib (0) =: = 1),
+     ? _assert (fib (1) =: = 1),
+     ? _assert (fib (2) =: = 2),
+     ? _assert (fib (3) =: = 3),
+     ? _assert (fib (4) =: = 5),
+     ? _assert (fib (5) =: = 8),
+     ? _assertException (error, function_clause, fib (-1)),
+     ? _assert (fib (31) =: = 2178309)
+    ]**
+
+- EUnit exportará automáticamente a una función de prueba () para permitir la ejecución de las pruebas en el shell Erlang
+fib: test ()
+
+- La popular barra de herramientas de construcción de Erlang también es compatible con EUnit
+**`` ` de la unidad de barras de refuerzo
+ ``**
diff --git a/es-es/fsharp-es.html.markdown b/es-es/fsharp-es.html.markdown
new file mode 100644
index 00000000..b7f80c44
--- /dev/null
+++ b/es-es/fsharp-es.html.markdown
@@ -0,0 +1,629 @@
+---
+language: F#
+lang: es-es
+contributors:
+  - ['Scott Wlaschin', 'http://fsharpforfunandprofit.com/']
+translators:
+  - ['Angel Arciniega', 'https://github.com/AngelsProjects']
+filename: learnfsharp-es.fs
+---
+
+F# es un lenguaje de programación funcional y orientado a objetos. Es gratis y su código fuente está abierto. Se ejecuta en Linux, Mac, Windows y más.
+
+Tiene un poderoso sistema de tipado que atrapa muchos errores de tiempo de compilación, pero usa inferencias de tipados que le permiten ser leídos como un lenguaje dinámico.
+
+La sintaxis de F# es diferente de los lenguajes que heredan de C.
+
+- Las llaves no se usan para delimitar bloques de código. En cambio, se usa sangría (como en Python).
+- Los espacios se usan para separar parámetros en lugar de comas.
+
+Si quiere probar el siguiente código, puede ir a [tryfsharp.org](http://www.tryfsharp.org/Create) y pegarlo en [REPL](https://es.wikipedia.org/wiki/REPL).
+
+```fsharp
+// Los comentarios de una línea se escibren con una doble diagonal
+(* Los comentarios multilínea usan parentesis (* . . . *)
+
+-final del comentario multilínea- *)
+
+// ================================================
+// Syntaxis básica
+// ================================================
+
+// ------ "Variables" (pero no realmente) ------
+// La palabra reservada "let" define un valor (inmutable)
+let miEntero = 5
+let miFlotante = 3.14
+let miCadena = "hola"           // Tenga en cuenta que no es necesario ningún tipado
+
+// ------ Listas ------
+let dosACinco = [2;3;4;5]        // Los corchetes crean una lista con
+                                 // punto y coma para delimitadores.
+let unoACinco = 1 :: dosACinco   // :: Crea una lista con un nuevo elemento
+// El resultado es [1;2;3;4;5]
+let ceroACinco = [0;1] @ dosACinco   // @ Concatena dos listas
+
+// IMPORTANTE: las comas no se usan para delimitar,
+// solo punto y coma !
+
+// ------ Funciones ------
+// La palabra reservada "let" también define el nombre de una función.
+let cuadrado x = x * x          // Tenga en cuenta que no se usa paréntesis.
+cuadrado 3                      // Ahora, ejecutemos la función.
+                              // De nuevo, sin paréntesis.
+
+let agregar x y = x + y           // ¡No use add (x, y)! Eso significa
+                              // algo completamente diferente.
+agregar 2 3                       // Ahora, ejecutemos la función.
+
+// Para definir una función en varias líneas, usemos la sangría.
+// Los puntos y coma no son necesarios.
+let pares lista =
+   let esPar x = x%2 = 0     // Establece "esPar" como una función anidada
+   List.filter esPar lista    // List.filter es una función de la biblioteca
+                              // dos parámetros: una función que devuelve un
+                              // booleano y una lista en la que trabajar
+
+pares unoACinco               // Ahora, ejecutemos la función.
+
+// Puedes usar paréntesis para aclarar.
+// En este ejemplo, "map" se ejecuta primero, con dos argumentos,
+// entonces "sum" se ejecuta en el resultado.
+// Sin los paréntesis, "List.map" se pasará como argumento a List.sum.
+let sumaDeCuadradosHasta100 =
+   List.sum ( List.map cuadrado [1..100] )
+
+// Puedes redirigir la salida de una función a otra con "|>"
+// Redirigir datos es muy común en F#, como con los pipes de UNIX.
+
+// Aquí está la misma función sumOfSquares escrita usando pipes
+let sumaDeCuadradosHasta100piped =
+   [1..100] |> List.map cuadrado |> List.sum  // "cuadrado" se declara antes
+
+// Puede definir lambdas (funciones anónimas) gracias a la palabra clave "fun"
+let sumaDeCuadradosHasta100ConFuncion =
+   [1..100] |> List.map (fun x -> x*x) |> List.sum
+
+// En F#, no hay palabra clave "return". Una función siempre regresa
+// el valor de la última expresión utilizada.
+
+// ------ Coincidencia de patrones ------
+// Match..with .. es una sobrecarga de la condición de case/ switch.
+let coincidenciaDePatronSimple =
+   let x = "a"
+   match x with
+    | "a" -> printfn "x es a"
+    | "b" -> printfn "x es b"
+    | _ -> printfn "x es algo mas"   // guion bajo corresponde con todos los demás
+
+// F# no permite valores nulos por defecto - debe usar el tipado de Option
+// y luego coincide con el patrón.
+// Some(..) y None son aproximadamente análogos a los envoltorios Nullable
+let valorValido = Some(99)
+let valorInvalido = None
+
+// En este ejemplo, match..with encuentra una coincidencia con "Some" y "None",
+// y muestra el valor de "Some" al mismo tiempo.
+let coincidenciaDePatronDeOpciones entrada =
+   match entrada with
+    | Some i -> printfn "la entrada es un int=%d" i
+    | None -> printfn "entrada faltante"
+
+coincidenciaDePatronDeOpciones validValue
+coincidenciaDePatronDeOpciones invalidValue
+
+// ------ Viendo ------
+// Las funciones printf/printfn son similares a las funciones
+// Console.Write/WriteLine de C#.
+printfn "Imprimiendo un int %i, a float %f, a bool %b" 1 2.0 true
+printfn "Un string %s, y algo generico %A" "hola" [1;2;3;4]
+
+// También hay funciones printf/sprintfn para formatear datos
+// en cadena. Es similar al String.Format de C#.
+
+// ================================================
+// Mas sobre funciones
+// ================================================
+
+// F# es un verdadero lenguaje funcional - las funciones son
+// entidades de primer nivel y se pueden combinar fácilmente
+// para crear construcciones poderosas
+
+// Los módulos se utilizan para agrupar funciones juntas.
+// Se requiere sangría para cada módulo anidado.
+module EjemploDeFuncion =
+
+    // define una función de suma simple
+    let agregar x y = x + y
+
+    // uso básico de una función
+    let a = agregar 1 2
+    printfn "1+2 = %i" a
+
+    // aplicación parcial para "hornear en" los parámetros (?)
+    let agregar42 = agregar 42
+    let b = agregar42 1
+    printfn "42+1 = %i" b
+
+    // composición para combinar funciones
+    let agregar1 = agregar 1
+    let agregar2 = agregar 2
+    let agregar3 = agregar1 >> agregar2
+    let c = agregar3 7
+    printfn "3+7 = %i" c
+
+    // funciones de primer nivel
+    [1..10] |> List.map agregar3 |> printfn "la nueva lista es %A"
+
+    // listas de funciones y más
+    let agregar6 = [agregar1; agregar2; agregar3] |> List.reduce (>>)
+    let d = agregar6 7
+    printfn "1+2+3+7 = %i" d
+
+// ================================================
+// Lista de colecciones
+// ================================================
+
+// Il y a trois types de collection ordonnée :
+// * Les listes sont les collections immutables les plus basiques
+// * Les tableaux sont mutables et plus efficients
+// * Les séquences sont lazy et infinies (e.g. un enumerator)
+//
+// Des autres collections incluent des maps immutables et des sets
+// plus toutes les collections de .NET
+
+module EjemplosDeLista =
+
+    // las listas utilizan corchetes
+    let lista1 = ["a";"b"]
+    let lista2 = "c" :: lista1    // :: para una adición al principio
+    let lista3 = lista1 @ lista2   // @ para la concatenación
+
+    // Lista de comprensión (alias generadores)
+    let cuadrados = [for i in 1..10 do yield i*i]
+
+    //  Generador de números primos
+    let rec tamiz = function
+        | (p::xs) -> p :: tamiz [ for x in xs do if x % p > 0 then yield x ]
+        | []      -> []
+    let primos = tamiz [2..50]
+    printfn "%A" primos
+
+    // coincidencia de patrones para listas
+    let listaDeCoincidencias unaLista =
+        match unaLista with
+        | [] -> printfn "la lista esta vacia"
+        | [primero] -> printfn "la lista tiene un elemento %A " primero
+        | [primero; segundo] -> printfn "la lista es %A y %A" primero segundo
+        | _ -> printfn "la lista tiene mas de dos elementos"
+
+    listaDeCoincidencias [1;2;3;4]
+    listaDeCoincidencias [1;2]
+    listaDeCoincidencias [1]
+    listaDeCoincidencias []
+
+    // Récursion en utilisant les listes
+    let rec suma unaLista =
+        match unaLista with
+        | [] -> 0
+        | x::xs -> x + suma xs
+    suma [1..10]
+
+    // -----------------------------------------
+    // Funciones de la biblioteca estándar
+    // -----------------------------------------
+
+    // mapeo
+    let agregar3 x = x + 3
+    [1..10] |> List.map agregar3
+
+    // filtrado
+    let par x = x % 2 = 0
+    [1..10] |> List.filter par
+
+    // mucho más - consulte la documentación
+
+module EjemploDeArreglo =
+
+    // los arreglos usan corchetes con barras.
+    let arreglo1 = [| "a";"b" |]
+    let primero = arreglo1.[0]        // se accede al índice usando un punto
+
+    // la coincidencia de patrones de los arreglos es la misma que la de las listas
+    let coincidenciaDeArreglos una Lista =
+        match unaLista with
+        | [| |] -> printfn "la matriz esta vacia"
+        | [| primero |] -> printfn "el arreglo tiene un elemento %A " primero
+        | [| primero; second |] -> printfn "el arreglo es %A y %A" primero segundo
+        | _ -> printfn "el arreglo tiene mas de dos elementos"
+
+    coincidenciaDeArreglos [| 1;2;3;4 |]
+
+    // La biblioteca estándar funciona como listas
+    [| 1..10 |]
+    |> Array.map (fun i -> i+3)
+    |> Array.filter (fun i -> i%2 = 0)
+    |> Array.iter (printfn "el valor es %i. ")
+
+module EjemploDeSecuencia =
+
+    // Las secuencias usan llaves
+    let secuencia1 = seq { yield "a"; yield "b" }
+
+    // Las secuencias pueden usar yield y
+    // puede contener subsecuencias
+    let extranio = seq {
+        // "yield" agrega un elemento
+        yield 1; yield 2;
+
+        // "yield!" agrega una subsecuencia completa
+        yield! [5..10]
+        yield! seq {
+            for i in 1..10 do
+              if i%2 = 0 then yield i }}
+    // prueba
+    extranio |> Seq.toList
+
+    // Las secuencias se pueden crear usando "unfold"
+    // Esta es la secuencia de fibonacci
+    let fib = Seq.unfold (fun (fst,snd) ->
+        Some(fst + snd, (snd, fst + snd))) (0,1)
+
+    // prueba
+    let fib10 = fib |> Seq.take 10 |> Seq.toList
+    printf "Los primeros 10 fib son %A" fib10
+
+// ================================================
+// Tipos de datos
+// ================================================
+
+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
+    let dosTuplas = 1,2
+    let tresTuplas = "a",2,true
+
+    // Combinación de patrones para desempaquetar
+    let x,y = dosTuplas  // asignado x=1 y=2
+
+    // ------------------------------------
+    // Los tipos de registro tienen campos con nombre
+    // ------------------------------------
+
+    // Usamos "type" con llaves para definir un tipo de registro
+    type Persona = {Nombre:string; Apellido:string}
+
+    // Usamos "let" con llaves para crear un registro
+    let persona1 = {Nombre="John"; Apellido="Doe"}
+
+    // Combinación de patrones para desempaquetar
+    let {Nombre=nombre} = persona1    // asignado nombre="john"
+
+    // ------------------------------------
+    // Los tipos de unión (o variantes) tienen un conjunto de elección
+     // Solo un caso puede ser válido a la vez.
+    // ------------------------------------
+
+    // Usamos "type" con barra/pipe para definir una unión estándar
+    type Temp =
+        | GradosC of float
+        | GradosF of float
+
+    // Una de estas opciones se usa para crear una
+    let temp1 = GradosF 98.6
+    let temp2 = GradosC 37.0
+
+    // Coincidencia de patrón en todos los casos para desempaquetar (?)
+    let imprimirTemp = function
+       | GradosC t -> printfn "%f gradC" t
+       | GradosF t -> printfn "%f gradF" t
+
+    imprimirTemp temp1
+    imprimirTemp temp2
+
+    // ------------------------------------
+    // Tipos recursivos
+    // ------------------------------------
+
+    // Los tipos se pueden combinar recursivamente de formas complejas
+    // sin tener que crear subclases
+    type Empleado =
+      | Trabajador of Persona
+      | Gerente of Empleado lista
+
+    let jdoe = {Nombre="John";Apellido="Doe"}
+    let trabajador = Trabajador jdoe
+
+    // ------------------------------------
+    // Modelado con tipados (?)
+    // ------------------------------------
+
+    // Los tipos de unión son excelentes para modelar el estado sin usar banderas (?)
+    type DireccionDeCorreo =
+        | DireccionDeCorreoValido of string
+        | DireccionDeCorreoInvalido of string
+
+    let intentarEnviarCorreo correoElectronico =
+        match correoElectronico with // uso de patrones de coincidencia
+        | DireccionDeCorreoValido direccion -> ()   // enviar
+        | 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.
+
+    type ArticuloDelCarrito = { CodigoDelProducto: string; Cantidad: int }
+    type Pago = Pago of float
+    type DatosActivosDelCarrito = { ArticulosSinPagar: ArticuloDelCarrito lista }
+    type DatosPagadosDelCarrito = { ArticulosPagados: ArticuloDelCarrito lista; Pago: Pago}
+
+    type CarritoDeCompras =
+        | CarritoVacio  // sin datos
+        | CarritoActivo of DatosActivosDelCarrito
+        | CarritoPagado of DatosPagadosDelCarrito
+
+    // ------------------------------------
+    // Comportamiento nativo de los tipos
+    // ------------------------------------
+
+    // 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
+
+     // 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.
+    type JuegoDeCartas = Trebol | Diamante | Espada | Corazon
+    type Rango = Dos | Tres | Cuatro | Cinco | Seis | Siete | Ocho
+                | Nueve | Diez | Jack | Reina | Rey | As
+
+    let mano = [ Trebol,As; Corazon,Tres; Corazon,As;
+                 Espada,Jack; Diamante,Dos; Diamante,As ]
+
+    // orden
+    List.sort mano |> printfn "la mano ordenada es (de menos a mayor) %A"
+    List.max mano |> printfn "la carta más alta es%A"
+    List.min mano |> printfn "la carta más baja es %A"
+
+// ================================================
+// Patrones activos
+// ================================================
+
+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.
+
+    // "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" ...
+    let (|Digito|Latra|EspacioEnBlanco|Otros|) ch =
+       if System.Char.IsDigit(ch) then Digito
+       else if System.Char.IsLetter(ch) then Letra
+       else if System.Char.IsWhiteSpace(ch) then EspacioEnBlanco
+       else Otros
+
+    // ... y luego lo usamos para hacer que la lógica de análisis sea más clara
+    let ImprimirCaracter ch =
+      match ch with
+      | Digito -> printfn "%c es un Digito" ch
+      | Letra -> printfn "%c es una Letra" ch
+      | Whitespace -> printfn "%c es un Espacio en blanco" ch
+      | _ -> printfn "%c es algo mas" ch
+
+    // ver una lista
+    ['a';'b';'1';' ';'-';'c'] |> List.iter ImprimirCaracter
+
+    // -----------------------------------------
+    // FizzBuzz usando patrones activos
+    // -----------------------------------------
+
+    // 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.
+    let (|MultDe3|_|) i = if i % 3 = 0 then Some MultDe3 else None
+    let (|MultDe5|_|) i = if i % 5 = 0 then Some MultDe5 else None
+
+    // la función principal
+    let fizzBuzz i =
+      match i with
+      | MultDe3 & MultDe5 -> printf "FizzBuzz, "
+      | MultDe3 -> printf "Fizz, "
+      | MultDe5 -> printf "Buzz, "
+      | _ -> printf "%i, " i
+
+    // prueba
+    [1..20] |> List.iter fizzBuzz
+
+// ================================================
+// concisión
+// ================================================
+
+module EjemploDeAlgoritmo =
+
+    // F# tiene una alta relación señal / ruido, lo que permite leer el código
+    // casi como un algoritmo real
+
+    // ------ Ejemplo: definir una función sumaDeCuadrados ------
+    let sumaDeCuadrados n =
+       [1..n]                   // 1) Tome todos los números del 1 al n
+       |> List.map cuadrado     // 2) Elevar cada uno de ellos al cuadrado
+       |> List.sum              // 3) Realiza su suma
+
+    // prueba
+    sumaDeCuadrados 100 |> printfn "Suma de cuadrados = %A"
+
+    // ------ Ejemplo: definir una función de ordenación ------
+    let rec ordenar lista =
+       match lista with
+       // Si la lista está vacía
+       | [] ->
+            []                              // devolvemos una lista 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
+                |> List.filter (fun e -> e < primerElemento)
+                |> ordenar                  // y los ordenamos
+            let elementosMasGrandes =       // extraemos el mas grande
+                otrosElementos              // de los que permanecen
+                |> List.filter (fun e -> e >= primerElemento)
+                |> ordenar                  // y los ordenamos
+            // Combinamos las 3 piezas en una nueva lista que devolvemos
+            List.concat [elementosMasPequenios; [primerElemento]; elementosMasGrandes]
+
+    // prueba
+    ordenar [1;5;23;18;9;1;3] |> printfn "Ordenado = %A"
+
+// ================================================
+// Código asíncrono
+// ================================================
+
+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.
+
+    open System.Net
+    open System
+    open System.IO
+    open Microsoft.FSharp.Control.CommonExtensions
+
+    // Recuperar el contenido de una URL de forma asincrónica
+    let extraerUrlAsync url =
+        async {   // La palabra clave "async" y llaves
+                  // crear un objeto "asincrónico"
+            let solicitud = WebRequest.Create(Uri(url))
+            use! respuesta = solicitud.AsyncGetResponse()
+                // use! es una tarea asincrónica
+            use flujoDeDatos = resp.GetResponseStream()
+                // "use" dispara automáticamente la funcion close()
+                // en los recursos al final de las llaves
+            use lector = new IO.StreamReader(flujoDeDatos)
+            let html = lector.ReadToEnd()
+            printfn "terminó la descarga %s" url
+            }
+
+    // una lista de sitios para informar
+    let sitios = ["http://www.bing.com";
+                 "http://www.google.com";
+                 "http://www.microsoft.com";
+                 "http://www.amazon.com";
+                 "http://www.yahoo.com"]
+
+    // ¡Aqui vamos!
+    sitios
+    |> List.map extraerUrlAsync // crear una lista de tareas asíncrona
+    |> Async.Parallel           // decirle a las tareas que se desarrollan en paralelo
+    |> Async.RunSynchronously   // ¡Empieza!
+
+// ================================================
+// Compatibilidad .NET
+// ================================================
+
+module EjemploCompatibilidadNet =
+
+    // F# puede hacer casi cualquier cosa que C# pueda hacer, y se ajusta
+    // perfectamente con bibliotecas .NET o Mono.
+
+    // ------- 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"
+
+    // ------- Implementar interfaces sobre la marcha! -------
+
+    // Crea un nuevo objeto que implemente IDisposable
+    let crearRecurso name =
+       { new System.IDisposable
+         with member this.Dispose() = printfn "%s creado" name }
+
+    let utilizarYDisponerDeRecursos =
+        use r1 = crearRecurso "primer recurso"
+        printfn "usando primer recurso"
+        for i in [1..3] do
+            let nombreDelRecurso = sprintf "\tinner resource %d" i
+            use temp = crearRecurso nombreDelRecurso
+            printfn "\thacer algo con %s" nombreDelRecurso
+        use r2 = crearRecurso "segundo recurso"
+        printfn "usando segundo recurso"
+        printfn "hecho."
+
+    // ------- Código orientado a objetos -------
+
+    // F# es también un verdadero lenguaje OO.
+    // Admite clases, herencia, métodos virtuales, etc.
+
+    // interfaz de tipo genérico
+    type IEnumerator<'a> =
+        abstract member Actual : 'a
+        abstract MoverSiguiente : unit -> bool
+
+    // Clase base abstracta con métodos virtuales
+    [<AbstractClass>]
+    type Figura() =
+        // propiedades de solo lectura
+        abstract member Ancho : int with get
+        abstract member Alto : int with get
+        // método no virtual
+        member this.AreaDelimitadora = this.Alto * this.Ancho
+        // método virtual con implementación de la clase base
+        abstract member Imprimir : unit -> unit
+        default this.Imprimir () = printfn "Soy una Figura"
+
+    // clase concreta que hereda de su clase base y sobrecarga
+    type Rectangulo(x:int, y:int) =
+        inherit Figura()
+        override this.Ancho = x
+        override this.Alto = y
+        override this.Imprimir ()  = printfn "Soy un Rectangulo"
+
+    // prueba
+    let r = Rectangulo(2,3)
+    printfn "La anchura es %i" r.Ancho
+    printfn "El area es %i" r.AreaDelimitadora
+    r.Imprimir()
+
+    // ------- extensión de método  -------
+
+    // Al igual que en C#, F# puede extender las clases existentes con extensiones de método.
+    type System.String with
+       member this.EmpiezaConA = this.EmpiezaCon "A"
+
+    // prueba
+    let s = "Alice"
+    printfn "'%s' empieza con una 'A' = %A" s s.EmpiezaConA
+
+    // ------- eventos -------
+
+    type MiBoton() =
+        let eventoClick = new Event<_>()
+
+        [<CLIEvent>]
+        member this.AlHacerClick = eventoClick.Publish
+
+        member this.PruebaEvento(arg) =
+            eventoClick.Trigger(this, arg)
+
+    // prueba
+    let miBoton = new MiBoton()
+    miBoton.AlHacerClick.Add(fun (sender, arg) ->
+            printfn "Haga clic en el evento con arg=%O" arg)
+
+    miBoton.PruebaEvento("Hola Mundo!")
+```
+
+## Más información
+
+Para más demostraciones de F#, visite el sitio [Try F#](http://www.tryfsharp.org/Learn), o sigue la serie [why use F#](http://fsharpforfunandprofit.com/why-use-fsharp/).
+
+Aprenda más sobre F# en [fsharp.org](http://fsharp.org/).
diff --git a/es-es/learnsmallbasic-es.html.markdown b/es-es/learnsmallbasic-es.html.markdown
index 21208792..ff320afb 100644
--- a/es-es/learnsmallbasic-es.html.markdown
+++ b/es-es/learnsmallbasic-es.html.markdown
@@ -18,7 +18,7 @@ SmallBASIC fue desarrollado originalmente por Nicholas Christopoulos a finales d
 Versiones de SmallBASIC se han hecho para una serie dispositivos de mano antiguos, incluyendo Franklin eBookman y el Nokia 770. También se han publicado varias versiones de escritorio basadas en una variedad de kits de herramientas GUI, algunas de las cuales han desaparecido. Las plataformas actualmente soportadas son Linux y Windows basadas en SDL2 y Android basadas en NDK. También está disponible una versión de línea de comandos de escritorio, aunque no suele publicarse en formato binario.
 Alrededor de 2008 una gran corporación lanzó un entorno de programación BASIC con un nombre de similar. SmallBASIC no está relacionado con este otro proyecto.
 
-```SmallBASIC
+```
 REM Esto es un comentario
 ' y esto tambien es un comentario
 
diff --git a/es-es/markdown-es.html.markdown b/es-es/markdown-es.html.markdown
index 0505b4cb..e23a94ea 100644
--- a/es-es/markdown-es.html.markdown
+++ b/es-es/markdown-es.html.markdown
@@ -14,7 +14,7 @@ fácilmente a HTML (y, actualmente, otros formatos también).
 ¡Denme toda la retroalimentación que quieran! / ¡Sientanse en la libertad de hacer forks o pull requests!
 
 
-```markdown
+```md
 <!-- Markdown está basado en HTML, así que cualquier archivo HTML es Markdown
 válido, eso significa que podemos usar elementos HTML en Markdown como, por
 ejemplo, el comentario y no serán afectados por un parseador Markdown. Aún 
diff --git a/es-es/objective-c-es.html.markdown b/es-es/objective-c-es.html.markdown
index bdbce524..26cd14d9 100644
--- a/es-es/objective-c-es.html.markdown
+++ b/es-es/objective-c-es.html.markdown
@@ -13,7 +13,7 @@ Objective C es el lenguaje de programación principal utilizado por Apple para l
 Es un lenguaje de programación para propósito general que le agrega al lenguaje de programación C una mensajería estilo "Smalltalk".
 
 
-```objective_c
+```objectivec
 // Los comentarios de una sola línea inician con //
 
 /*
diff --git a/es-es/python3-es.html.markdown b/es-es/python3-es.html.markdown
index 05fd7065..3236e73a 100644
--- a/es-es/python3-es.html.markdown
+++ b/es-es/python3-es.html.markdown
@@ -14,8 +14,6 @@ Es básicamente pseudocódigo ejecutable.
 
 ¡Comentarios serán muy apreciados! Pueden contactarme en [@louiedinh](http://twitter.com/louiedinh) o louiedinh [at] [servicio de email de google]
 
-Nota: Este artículo aplica a Python 2.7 específicamente, pero debería ser aplicable a Python 2.x. ¡Pronto un recorrido por Python 3!
-
 ```python
 
 # Comentarios de una línea comienzan con una almohadilla (o signo gato)
@@ -39,6 +37,8 @@ Nota: Este artículo aplica a Python 2.7 específicamente, pero debería ser apl
 
 # Excepto la división la cual por defecto retorna un número 'float' (número de coma flotante)
 35 / 5  # => 7.0
+# Sin embargo también tienes disponible división entera
+34 // 5 # => 6
 
 # Cuando usas un float, los resultados son floats
 3 * 2.0 # => 6.0
@@ -87,11 +87,14 @@ not False  # => True
 # .format puede ser usaro para darle formato a los strings, así:
 "{} pueden ser {}".format("strings", "interpolados")
 
-# Puedes repetir los argumentos de formateo para ahorrar tipeos.
+# Puedes reutilizar los argumentos de formato si estos se repiten.
 "{0} sé ligero, {0} sé rápido, {0} brinca sobre la {1}".format("Jack", "vela") #=> "Jack sé ligero, Jack sé rápido, Jack brinca sobre la vela"
 # Puedes usar palabras claves si no quieres contar.
-"{nombre} quiere comer {comida}".format(nombre="Bob", food="lasaña") #=> "Bob quiere comer lasaña"
-
+"{nombre} quiere comer {comida}".format(nombre="Bob", comida="lasaña") #=> "Bob quiere comer lasaña"
+# También puedes interpolar cadenas usando variables en el contexto
+nombre = 'Bob'
+comida = 'Lasaña'
+f'{nombre} quiere comer {comida}'  #=> "Bob quiere comer lasaña"
 
 # None es un objeto
 None  # => None
@@ -101,12 +104,13 @@ None  # => None
 "etc" is None #=> False
 None is None  #=> True
 
-# None, 0, y strings/listas/diccionarios vacíos(as) todos se evalúan como False.
+# None, 0, y strings/listas/diccionarios/conjuntos vacíos(as) todos se evalúan como False.
 # Todos los otros valores son True
 bool(0)  # => False
 bool("")  # => False
 bool([]) #=> False
 bool({}) #=> False
+bool(set()) #=> False
 
 
 ####################################################
@@ -170,7 +174,7 @@ lista + otra_lista #=> [1, 2, 3, 4, 5, 6] - Nota: lista y otra_lista no se tocan
 # Concatenar listas con 'extend'
 lista.extend(otra_lista) # lista ahora es [1, 2, 3, 4, 5, 6]
 
-# Chequea la existencia en una lista con 'in'
+# Verifica la existencia en una lista con 'in'
 1 in lista #=> True
 
 # Examina el largo de una lista con 'len'
@@ -196,7 +200,7 @@ d, e, f = 4, 5, 6
 e, d = d, e     # d ahora es 5 y e ahora es 4
 
 
-# Diccionarios almacenan mapeos
+# Diccionarios relacionan llaves y valores
 dicc_vacio = {}
 # Aquí está un diccionario prellenado
 dicc_lleno = {"uno": 1, "dos": 2, "tres": 3}
@@ -213,7 +217,7 @@ list(dicc_lleno.keys()) #=> ["tres", "dos", "uno"]
 list(dicc_lleno.values()) #=> [3, 2, 1]
 # Nota - Lo mismo que con las llaves, no se garantiza el orden.
 
-# Chequea la existencia de una llave en el diccionario con 'in'
+# Verifica la existencia de una llave en el diccionario con 'in'
 "uno" in dicc_lleno #=> True
 1 in dicc_lleno #=> False
 
@@ -253,7 +257,7 @@ conjunto_lleno | otro_conjunto #=> {1, 2, 3, 4, 5, 6}
 # Haz diferencia de conjuntos con -
 {1,2,3,4} - {2,3,5} #=> {1, 4}
 
-# Chequea la existencia en un conjunto con 'in'
+# Verifica la existencia en un conjunto con 'in'
 2 in conjunto_lleno #=> True
 10 in conjunto_lleno #=> False
 
@@ -262,7 +266,7 @@ conjunto_lleno | otro_conjunto #=> {1, 2, 3, 4, 5, 6}
 ## 3. Control de Flujo
 ####################################################
 
-# Let's just make a variable
+# Creemos una variable para experimentar
 some_var = 5
 
 # Aquí está una declaración de un 'if'. ¡La indentación es significativa en Python!
@@ -275,18 +279,17 @@ else:           # Esto también es opcional.
     print("una_variable es de hecho 10.")
 
 """
-For itera sobre listas
+For itera sobre iterables (listas, cadenas, diccionarios, tuplas, generadores...)
 imprime:
     perro es un mamifero
     gato es un mamifero
     raton es un mamifero
 """
 for animal in ["perro", "gato", "raton"]:
-    # Puedes usar % para interpolar strings formateados
     print("{} es un mamifero".format(animal))
 
 """
-`range(número)` retorna una lista de números
+`range(número)` retorna un generador de números
 desde cero hasta el número dado
 imprime:
     0
@@ -323,7 +326,7 @@ except IndexError as e:
 
 dicc_lleno = {"uno": 1, "dos": 2, "tres": 3}
 nuestro_iterable = dicc_lleno.keys()
-print(nuestro_iterable) #=> range(1,10). Este es un objeto que implementa nuestra interfaz Iterable
+print(nuestro_iterable) #=> dict_keys(['uno', 'dos', 'tres']). Este es un objeto que implementa nuestra interfaz Iterable
 
 Podemos recorrerla.
 for i in nuestro_iterable:
@@ -420,6 +423,10 @@ filter(lambda x: x > 5, [3, 4, 5, 6, 7]) #=> [6, 7]
 # Podemos usar listas por comprensión para mapeos y filtros agradables
 [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]
+# también hay diccionarios
+{k:k**2 for k in range(3)} #=> {0: 0, 1: 1, 2: 4}
+# y conjuntos por comprensión
+{c for c in "la cadena"} #=> {'d', 'l', 'a', 'n', ' ', 'c', 'e'}
 
 ####################################################
 ## 5. Classes
diff --git a/es-es/visualbasic-es.html.markdown b/es-es/visualbasic-es.html.markdown
index c7f581c0..ca00626b 100644
--- a/es-es/visualbasic-es.html.markdown
+++ b/es-es/visualbasic-es.html.markdown
@@ -10,7 +10,7 @@ filename: learnvisualbasic-es.vb
 lang: es-es
 ---
 
-```vb
+```
 Module Module1
 
     Sub Main()