feat: add functions comparison section

Author: Phosphorus-M

src/es/SUMMARY.md

@@ -7,8 +7,9 @@
     - [Punto de entrada](./quick-comparisons/entry-point.md)
     - [Tooling](./quick-comparisons/tooling.md)
     - [Tipos escalares](./quick-comparisons/scalar-types.md)
-    - [Tuplas y Colecciones](./quick-comparisons/tuples-and-collections.md)
     - [Declaración de variables](./quick-comparisons/variable-declaration.md)
+    - [Tuplas y Colecciones](./quick-comparisons/tuples-and-collections.md)
+    - [Funciones](./quick-comparisons/functions.md)
     - [Casting](./quick-comparisons/casting.md)
     - [Control de flujo](./quick-comparisons/control-flow.md)
     - [Nulabilidad y Opcionalidad](./quick-comparisons/nullability-and-optionality.md)

src/es/quick-comparisons/functions.md

@@ -0,0 +1,88 @@
+# Funciones
+
+Las funciones en Rust y Go tienen algunas similitudes pero también diferencias 
+importantes debido a la filosofía de cada lenguaje.
+
+|                             | Go                                                | Rust                            |
+| --------------------------- | ------------------------------------------------- | ------------------------------- |
+| Palabra clave               | `func`                                            | `fn`                            |
+| Tipado del parámetro        | Después del nombre del parámetro                  | Después de los dos puntos (`:`) |
+| Retorno                     | Después de paréntesis, antes de `{`               | Después de `->`                 |
+
+
+Veamos un ejemplo de esto, en Go haríamos algo como esto:
+
+```go,no_run
+func suma(a int, b int) int {
+    return a + b
+}
+```
+
+Mientras que lo mismo en Rust sería:
+
+```rust,ignore
+fn suma(a: i32, b: i32) -> i32 {
+    return a + b;
+}
+```
+
+Bastante parecido ¿verdad? Sin embargo esa no es la forma más idiomatica de 
+hacerlo en Rust, sino que lo más idiomatico seria utilizar una característica de 
+Rust, en la que la ultima expresión de la función tiene un return implícito si
+es que no termina en `;`:
+
+```rust,ignore
+fn suma(a: i32, b: i32) -> i32 {
+    a + b // retorna la ultima expresión si no termina en ;
+}
+```
+
+Esto funcionara con todo lo que sea una expresión como por ejemplo lo son los 
+controles de flujos, que veremos más adelante.
+
+## Closures
+
+También podemos trabajar como Closures las funciones, en Go esto se vería de 
+esta forma:
+
+```go
+#package main
+# 
+#import (
+#	"fmt"
+#)
+# 
+#func main() {
+    x := 5
+    sumar := func(y int) int {
+        return x + y
+    }
+    fmt.Println(sumar(3)) // Imprime 8
+#}
+```
+
+Mientras que en Rust seria:
+
+```rust
+    let x = 5;
+    let sumar = |y| x + y;  // closure que "captura" x
+
+    println!("{}", sumar(3)); // Imprime 8
+```
+
+Algo curioso es que en la closure de Rust no es necesario definir el tipo del 
+parámetro si es que no es ambiguo, en este caso como solo tiene un caso y el
+valor que recibe es `3` logra entender que `y` es de tipo `i32`, sin embargo
+podríamos tiparlo nosotros de ser necesario:
+
+
+```rust
+    let x = 5;
+    let sumar = |y:i32| x + y;  // closure que "captura" x
+
+    println!("{}", sumar(3)); // Imprime 8
+```
+
+Veremos más acerca del uso avanzado de funciones en algunos capítulos más 
+adelante.
+

src/es/quick-comparisons/tuples-and-collections.md

@@ -57,6 +57,9 @@ fn getCoordinates() -> (i32, i32) {
 }
 ```
 
+Aunque esto es un pequeño spoiler de lo que explicaremos acerca de las 
+funciones más adelante.
+
 ## Arrays / Slices / Vectores
 
 ### Arrays
@@ -162,7 +165,7 @@ Deberá fallar en tiempo de ejecución, Rust para solucionar nos da el método
 ```
 
 El método `get` nos devolverá un `Option<T>` profundizaremos sobre este tipo
-en el siguiente capitulo.
+en los siguientes capítulos.
 
 Por otro lado hay que aclarar que tanto los array, como los slices y los `Vec`,
 son tipos de datos que solo almacenan un único tipo de dato dentro, como pueden