Some modifications

assets/css/app.css

@@ -24,26 +24,32 @@ body {
 section>div>div>h1 {
   font-size: 1.5rem;
   margin: 0.5rem auto;
+  width: 100%;
 }
 section>div>div>h2 {
   font-size: 1.3rem;
   margin: 0.5rem auto;
+  width: 100%;
 }
 section>div>div>h3 {
   font-size: 1.2rem;
   margin: 0.5rem auto;
+  width: 100%;
 }
 section>div>div>h4 {
   font-size: 1.1rem;
   margin: 0.2rem auto;
+  width: 100%;
 }
 section>div>div>h5 {
   font-size: 1rem;
   margin: 0.2rem auto;
+  width: 100%;
 }
 section>div>div>h6 {
   font-size: 0.5rem;
   margin: 0.2rem auto;
+  width: 100%;
 }
 
 section>div>div{
@@ -94,11 +100,16 @@ ul > li::marker {
 
 /* Personalización de listas ordenadas */
 ol > li::marker {
-  content: none; /* Usa el comportamiento predeterminado del navegador */
-  color: var(--dark-yellow); /* Color de los números */
+  color: var(--yellow); /* Color de los números */
   font-weight: bold; /* Hace los números más prominentes */
 }
 
+ol {
+  list-style: initial;
+  list-style-type: decimal;
+  @apply list-decimal;
+}
+
 /* Estilos para listas anidadas */
 ul ul,
 ol ol,
@@ -109,7 +120,7 @@ ol ul {
 
 ul ul > li::marker {
   content: "◦ "; /* Cambia el marcador de listas desordenadas anidadas */
-  color: var(--stroke-color);
+  color: var(--yellow);
 }
 
 ol ol > li::marker {

content/1.introduccion.md

@@ -2,6 +2,7 @@
 nextPath: "porque-rust"
 previousPath: ""
 editor: false
+order: 1
 ---
 
 # Introducción a Rust: El Lenguaje del Futuro en Programación de Sistemas

content/10.bool-and-float.md

@@ -0,0 +1,69 @@
+---
+nextPath: "other"
+previousPath: "shadowing"
+initialCode: |
+  fn main() {
+    // Paso 1: Declara un booleano 
+    let tienes_hambre ...
+
+    // Paso 2: Declara un flotante para tu peso
+    let peso ...
+
+    // Paso 4: Imprime el peso
+    println!("Tu peso es: {peso} kg");
+    println!("¿Tienes hambre? {tienes_hambre}");
+  }
+tests:
+    - should be contain `.`
+    - should be contain `true` `false`
+order: 10
+---
+# Tipos de datos
+
+En Rust existen muchos tipos de datos, a lo largo de las lecciones anteriores hemos visto superficialmente
+algunos, no obstante no hemos profundizado mucho en ellos, pero en esta lección nos centraremos en dos de los más comunes: los booleanos y los números de punto flotante.
+
+
+## 🔹 Booleanos (`bool`)
+
+Un booleano solo puede tener dos valores: `true` (verdadero) o `false` (falso).
+Se usan principalmente en expresiones lógicas y estructuras de control, como `if`, `while` y `match`.
+
+Ejemplo:
+
+```rust
+let es_rust_divertido: bool = true;
+let tiene_gluten: bool = false;
+
+if es_rust_divertido {
+    println!("¡Rust es genial!");
+}
+```
+
+## 🔹 Flotantes (`f32` y `f64`)
+
+Los números de punto flotante representan valores con decimales.
+Rust tiene dos tipos:
+
+* `f32`: precisión simple (32 bits).
+* `f64`: precisión doble (64 bits, valor por defecto).
+
+Ejemplo:
+
+```rust
+let pi: f64 = 3.14159;
+let temperatura: f32 = 36.6;
+
+println!("El valor de pi es {pi}");
+println!("La temperatura es {temperatura}");
+```
+
+Los flotantes permiten operaciones matemáticas, como suma, resta, multiplicación y división.
+
+---
+
+## ✍️ Ejercicio
+
+1. Declara una variable booleana que indique si **tienes hambre**.
+2. Declara una variable flotante que guarde tu **peso**.
+4. Imprime el peso en pantalla y la variable que nos permite saber si tienes hambre.

content/2.porque-rust.md

@@ -2,6 +2,7 @@
 nextPath: "versiones"
 previousPath: "introduccion"
 editor: false
+order: 2
 ---
 
 # ¿Por Qué Rust?

content/3.versiones.md

@@ -2,6 +2,7 @@
 nextPath: "instalar"
 previousPath: "porque-rust"
 editor: false
+order: 3
 ---
 
 # Stable, Beta, Nightly. ¿Que es esto?

content/4.instalar.md

@@ -2,6 +2,7 @@
 nextPath: "editor"
 previousPath: "versiones"
 editor: false
+order: 4
 ---
 
 # Instalación de Rust con Rustup: Una Guía Rápida

content/5.editor.md

@@ -2,6 +2,7 @@
 nextPath: "hola-mundo"
 previousPath: "instalar"
 editor: false
+order: 5
 ---
 
 # Configurando Tu Entorno de Desarrollo para Rust: Guía para los Editores de Texto Más Comunes

content/6.hola-mundo.md

@@ -2,6 +2,7 @@
 nextPath: "variables"
 previousPath: "editor"
 expectedResponse: "Hello, world!\n"
+order: 6
 ---
 
 

content/7.variables.md

@@ -11,6 +11,7 @@ initialCode: |
     contador = 1
     println!("nuevo contador = {contador}");
   }
+order: 7
 
 ---
 

content/8.constants.md

@@ -1,5 +1,5 @@
 ---
-nextPath: ""
+nextPath: "shadowing"
 previousPath: "variables"
 expectedResponse: "Un día tiene 86400 segundos\n"
 initialCode: |
@@ -14,7 +14,7 @@ initialCode: |
       println!("Un día tiene ??? segundos");
       // Reemplaza ??? con el cálculo correcto
   }
-
+order: 8
 ---
 
 # Constantes

content/9.shadowing.md

@@ -0,0 +1,57 @@
+---
+nextPath: "bool-and-float"
+previousPath: "constants"
+expectedResponse: "El valor final es: 15\n"
+initialCode: |
+  fn main() {
+    // Crea la variable valor con el string "10"
+
+    // Asigna el parseo a un entero usando shadowing a la variable valor
+
+    valor.parse::<i32>().expect("No es un número");
+
+    // Suma 5 al valor
+
+    // Muestra el resultado
+    println!("El valor final es: {valor}");
+  }
+order: 9
+---
+
+# Shadowing
+
+En Rust, cuando declaramos una variable con `let`, su nombre queda asociado a un valor en memoria.
+El **shadowing** ocurre cuando volvemos a declarar una variable con el mismo nombre que otra anterior, usando nuevamente `let`. Esto *sombrea* (shadow) la variable anterior, es decir, la nueva declaración la reemplaza en el alcance actual.
+
+Lo importante es que, a diferencia de hacer la variable `mut`, el shadowing nos permite:
+
+* **Cambiar el valor** asociado a la variable.
+* **Cambiar el tipo** de la variable.
+
+Ejemplo:
+
+```rust
+fn main() {
+    let x = 5;       // x es un número entero
+    let x = x + 1;   // x ahora vale 6
+    let x = "texto"; // x ahora es un string, diferente tipo
+    println!("{x}");
+}
+```
+
+En este caso, la variable `x` cambia tanto de valor como de tipo, algo que no sería posible con `mut`. Esto lo hace muy útil para transformar datos paso a paso sin necesidad de inventar nuevos nombres de variables.
+
+---
+
+### 📝 Ejercicio
+
+Crea un programa que:
+
+1. Defina una variable llamada `valor` con el número `10`.
+2. Use **shadowing** para:
+    * Parsear `valor` a un entero.
+        * Para esto usaremos el método `parse::<i32>()` que convierte un string a un entero de 32 bits.
+        * Como `parse` puede fallar, usaremos `expect("No es un número")` para manejar el caso de error.
+3. Luego **suma** `5` al valor.
+4. Imprime el resultado final.
+