fix: exclude no_run Go code blocks from selection for Run button

Author: Phosphorus-M

src/es/quick-comparisons/casting.md

@@ -4,7 +4,7 @@ Tanto Go como Rust tienen casteos explicitos, para transformar en Go un tipo de
 dato a otro generalmente se ejecuta una función como puede verse en el ejemplo
 de abajo.
 
-```go
+```go,no_run
 var x int = 10
 var y float64 = float64(x)
 var z int32 = int32(x)
@@ -16,7 +16,7 @@ En Rust también esto también requerira un casting explicito, pe´ro en lugar d
 usando una función con el nombre del tipo, utilizamos directamente la keyword
 `as` como se puede ver en el ejemplo de abajo:
 
-```rust
+```rust,no_run
 let x: i32 = 10;
 let y: f64 = x as f64;
 let z: u8 = x as u8;
@@ -25,7 +25,7 @@ let z: u8 = x as u8;
 Al igual que en Go, Rust al  el operador as trunca o satura en algunos casos 
 (por ejemplo, de i32 a u8). 
 
-```rust
+```rust,no_run
 let big: u32 = 300;
 let small: u8 = big as u8;
 ```
@@ -45,28 +45,28 @@ función asociada/método gracias a ese trait.
 
 Por lo que podríamos hacer 
 
-```rust
+```rust,no_run
 let s = String::from(42);
 ```
 
 Pero también tendríamos el método `.into()`: 
 
 
-```rust
+```rust,no_run
 let s: String = 42.into();
 ```
 
 También podrían haber alternativas drásticamente diferentes como:
 
-```rust
+```rust,no_run
 let s = 42.to_string();
 ```
 
 Sin embargo la forma más segura de hacer una conversión entre tipos es con 
 `TryFrom`, ya que con este trait podemos validar si hay algún error durante la 
 conversión:
 
-```rust
+```rust,no_run
 let n: i32 = 300;
 let r: Result<u8, _> = n.try_into();
 ```
@@ -107,7 +107,7 @@ Rust provee estas funciones que te permiten capturar los posibles errores.
 En Go si quisieras hacer lo que hace el `try_from()` o el `try_into()` debes 
 validarlo a mano como con algo así:
 
-```go
+```go,no_run
 if x >= 0 && x <= 255 {
     var y uint8 = uint8(x)
     fmt.Println("Seguro:", y)
@@ -118,7 +118,7 @@ if x >= 0 && x <= 255 {
 
 En Rust si inferimos el error podríamos tener algo como esto:
 
-```rust
+```rust,no_run
 let n: i32 = 300;
 let r = u8::try_from(n);
 ```

src/es/quick-comparisons/control-flow.md

@@ -40,9 +40,9 @@ En Go suele representarse el control de flujo de esta forma:
 # func main() {
 #   x := 0
     if x > 0 {
-        fmt.Println("positivo")
+        fmt.Println("positivo")        
     } else {
-        fmt.Println("negativo")
+        fmt.Println("negativo")        
     }
 # }
 ```
@@ -60,9 +60,9 @@ En Go suele representarse el control de flujo de esta forma:
 # func main() {
 #   x := 1
     if x > 0 {
-        fmt.Println("positivo")
+        fmt.Println("positivo")        
     } else {
-        fmt.Println("negativo")
+        fmt.Println("negativo")        
     }
 # }
 ```
@@ -88,26 +88,26 @@ Rust lo representaría de forma similar:
             <td>
 
 ```rust
-# let x = 0;
-# 
-if x > 0 {
-    println!("positivo");
-} else {
-    println!("negativo");
-}
+    #let x = 0;
+    # 
+    if x > 0 {
+        println!("positivo");        
+    } else {
+        println!("negativo");        
+    }
 ```
 
 </td>
                 <td>
 
 ```rust
-# let x = 1;
-#
-if x > 0 {
-    println!("positivo");
-} else {
-    println!("negativo");
-}
+    # let x = 1;
+    #
+    if x > 0 {
+        println!("positivo");        
+    } else {
+        println!("negativo");        
+    }
 ```
 
 </td>
@@ -117,8 +117,10 @@ if x > 0 {
 
 Pero en Rust podemos además asignar el resultado de la expresión a una variable:
 
-```rust,ignore
-let mensaje = if x > 0 { "positivo" } else { "negativo" };
+```rust
+    #let x = 0;
+    let mensaje = if x > 0 { "positivo" } else { "negativo" };
+    #println!("{mensaje}")
 ```
 
 ### Switch vs Match
@@ -139,24 +141,34 @@ let mensaje = if x > 0 { "positivo" } else { "negativo" };
 Ejemplo en Go:
 
 ```go
-switch day {
-    case "lunes":
-        fmt.Println("Inicio de semana")
-    case "viernes":
-        fmt.Println("Casi fin")
-    default:
-        fmt.Println("Otro día")
-}
+#package main
+#
+#import (
+#	"fmt"
+#)
+# 
+#func main() {
+#    day := "lunes"
+    switch day {
+        case "lunes":
+            fmt.Println("Inicio de semana")
+        case "viernes":
+            fmt.Println("Casi fin")
+        default:
+            fmt.Println("Otro día")
+    }
+#}
 ```
 
 En Rust, el equivalente sería:
 
-```rust,ignore
-match day {
-    "lunes" => println!("Inicio de semana"),
-    "viernes" => println!("Casi fin"),
-    _ => println!("Otro día"),
-}
+```rust
+#     let day = "lunes";
+    match day {
+        "lunes" => println!("Inicio de semana"),
+        "viernes" => println!("Casi fin"),
+        _ => println!("Otro día"),
+    }
 ```
 
 ### Bucles
@@ -171,47 +183,55 @@ match day {
 En Go podríamos hacer lo siguiente:
 
 ```go
-for i := 0; i < 5; i++ {
-    fmt.Println(i)
-}
+#package main
+# 
+#import (
+#	"fmt"
+#)
+# 
+#func main() {
+    for i := 0; i < 5; i++ {
+        fmt.Println(i)
+    }
+#}
 ```
 
 En Rust de forma similar podríamos conseguir el mismo efecto:
 
 ```rust
-for i in 0..5 {
-    println!("{}", i);
-}
+    for i in 0..5 {
+        println!("{}", i);
+    }
 ```
 
 #### Bucle Infinito
 
 En Go un bucle infinito podríamos hacerlo de la siguiente forma:
 
-```go
-for {
-    fmt.Println("infinito")
-}
+```go,no_run
+    for {
+        fmt.Println("infinito")
+    }
 ``` 
 
 Mientras que en Rust usaríamos:
 
-```rust,ignore
-loop {
-    println!("infinito");
-}
+```rust,no_run
+    loop {
+        println!("infinito");
+    }
 ```
 
 #### Bucles con While
 
 Go no tiene bucle `while` pero en Rust si tenemos.
 
 ```rust
-let mut i = 0;
-while i < 5 {
-    println!("{}", i);
-    i += 1;
-}
+    let mut i = 0;
+    while i < 5 {
+        println!("{}", i);
+        i += 1;
+    }
 ```
 
 El bucle `while` puede resultar útil cuando buscamos una condición de corte
@@ -224,16 +244,16 @@ contadores.
 Ambos lenguajes los tienen, pero Rust permite `break` con valor en `loop`:
 
 ```rust
-let mut x = 0;
+    let mut x = 0;
 
-let resultado = loop {
-    if x > 10 {
-        break x * 2; // aquí
-    }
-    x += 1;
-};
+    let resultado = loop {
+        if x > 10 {
+            break x * 2; // aquí
+        }
+        x += 1;
+    };
 
-println!("{resultado}");
+    println!("{resultado}");
 ```
 
 De esta forma se asigna el valor del `break` dentro de `resultado`.
@@ -258,11 +278,11 @@ Eso no existe en Go.
 Rust permite patrones destructurantes muy potentes que no existen en Go.
 
 ```rust
-let punto = (0, 5);
+    let punto = (0, 5);
 
-if let (0, y) = punto {
-    println!("Está sobre el eje Y en {y}");
-}
+    if let (0, y) = punto {
+        println!("Está sobre el eje Y en {y}");
+    }
 ```
 
 En este caso si `opcion` es equivalente a la variante `Some`, se extrae el valor
@@ -275,13 +295,13 @@ Con `match` podríamos hacer algo similar, pero en este caso debemos cubrir amba
 variantes, el `match` es exhaustivo, sino tenemos en cuenta ambos casos
 obtendremos un error en compilación:
 
-```rust
-let color = "azul";
+```rust,editable
+    let color = "azul";
 
-match color {
-    "rojo" => println!("El color es rojo"),
-    "verde" => println!("El color es verde"),
-    otro => println!("Otro color, el cual es {otro}"),
-}
+    match color {
+        "rojo" => println!("El color es rojo"),
+        "verde" => println!("El color es verde"),
+        otro => println!("Otro color, el cual es {otro}"),
+    }
 ```