Dart desde cero hasta experto

// Un primer vistazo. Todo esto se explica capítulo por capítulo.
class Usuario {
  final String nombre;
  final int edad;

  Usuario({required this.nombre, required this.edad});

  bool get esMayorDeEdad => edad >= 18;

  @override
  String toString() => 'Usuario($nombre, $edad)';
}

void main() {
  final usuarios = [
    Usuario(nombre: 'Ana', edad: 34),
    Usuario(nombre: 'Luis', edad: 15),
  ];

  final adultos = usuarios.where((u) => u.esMayorDeEdad).toList();

  for (final u in adultos) {
    print('Hola $u');
  }
}

sudo apt-get update
sudo apt-get install -y apt-transport-https ca-certificates curl gnupg wget

wget -qO- https://dl-ssl.google.com/linux/linux_signing_key.pub | sudo gpg --dearmor -o /usr/share/keyrings/dart.gpg

echo 'deb [signed-by=/usr/share/keyrings/dart.gpg arch=amd64] https://storage.googleapis.com/download.dartlang.org/linux/debian stable main' | sudo tee /etc/apt/sources.list.d/dart_stable.list

sudo apt-get update && sudo apt-get install -y dart

# ejemplo con el SDK descomprimido en ~/herramientas
mkdir -p ~/herramientas && cd ~/herramientas
# descarga el .zip adecuado a tu arquitectura (x64 o arm64) y luego:
unzip dartsdk-linux-x64.zip

# añade al PATH permanentemente (bash):
echo 'export PATH="$PATH:$HOME/herramientas/dart-sdk/bin"' >> ~/.bashrc
source ~/.bashrc

# si usas zsh, hazlo en ~/.zshrc; en fish: fish_add_path ~/herramientas/dart-sdk/bin

void main() {
  print('Hola, mundo');
}

void main() {
  String saludo = 'Dart';
  int anio = 2026;
  print('Aprendiendo $saludo en el año $anio');
}

// Comentario de una línea.

/*
   Comentario de bloque:
   puede ocupar varias líneas.
*/

/// Documentación oficial: describe funciones y clases.
/// Los IDE muestran este texto en el autocompletado.
int duplicar(int n) => n * 2;

// 1) La forma habitual
void main() {
  print('Sin argumentos');
}

// 2) Recibiendo argumentos de la línea de comandos: dart run app.dart Ana 30
void main(List<String> args) {
  print('Argumentos recibidos: $args');
}

// 3) Asíncrona (la verás mucho en Flutter y servidores)
Future<void> main() async {
  print('Puedo usar await aquí');
}

void main() {
  print('Un solo valor');
  print('Varios:', ); // ERROR real: print acepta UN argumento
}

void main() {
  var producto = 'Café';
  var precio = 1.5;
  print('$producto cuesta $precio euros'); // Café cuesta 1.5 euros
}

void main() {
  // Declaración explícita: dices tú el tipo
  String ciudad = 'Madrid';
  int habitantes = 3300000;
  double temperatura = 21.7;
  bool esCapital = true;

  // Inferencia: Dart deduce el tipo a partir del valor inicial
  var pais = 'España';        // se infiere String
  var codigos = [1, 2, 3];    // se infiere List<int>

  print('$ciudad tiene $habitantes habitantes. ¿Capital? $esCapital');
  print('$pais - $codigos - $temperatura');
}

var edad = 34;
edad = 35;        // bien: sigue siendo int
// edad = 'treinta'; // ERROR: A value of type 'String' can't be assigned...

void main() {
  dynamic flexible = 'ahora soy texto';
  print(flexible.length);       // 16

  flexible = 42;
  print(flexible + 8);          // 50

  flexible = [1, 2];
  print(flexible.first);        // 1
}

void main() {
  int x;
  print(x); // ERROR: The variable 'x' can't be used because it is potentially unassigned.
}

void main() {
  int enteros = -42;
  int hex = 0xFF;            // hexadecimal: 255
  int grande = 1_000_000;    // separador visual (Dart 3.6+): un millón

  double precio = 19.99;
  double cientifico = 2.5e8; // 250000000.0

  num cualquiera = 10;       // num acepta int...
  cualquiera = 3.14;         // ...y también double

  print('$enteros $hex $grande');
  print('$precio $cientifico $cualquiera');
}

void main() {
  var suma = 7 + 5;      // 12
  var resta = 7 - 5;     // 2
  var mult = 7 * 5;      // 35

  var division = 7 / 2;  // 3.5  -> SIEMPRE devuelve double
  var entera = 7 ~/ 2;   // 3    -> división entera (trunca)
  var modulo = 7 % 2;    // 1    -> resto

  print('division: $division | entera: $entera | resto: $modulo');

  // El operador ~ es útil para saber si un número es par:
  print(10 % 2 == 0);    // true -> es par
}

void main() {
  int n = 7;
  print(n.isEven);          // false
  print(n.isOdd);           // true
  print(n.isNegative);      // false
  print((-n).abs());        // 7
  print(n.toString());      // '7'
  print(n.toRadixString(2)); // '111' en binario

  double d = 3.14159;
  print(d.toStringAsFixed(2)); // '3.14' (redondeado, como texto)
  print(d.round());         // 3   redondeo clásico
  print(d.ceil());          // 4   techo
  print(d.floor());         // 3   suelo
  print(d.truncate());      // 3   elimina decimales

  double infinito = 1 / 0;
  print(infinito.isInfinite); // true
}

void main() {
  // De texto a número
  int a = int.parse('123');
  double b = double.parse('3.14');
  int? c = int.tryParse('hola'); // null en vez de excepción
  print('$a $b $c');

  // De número a texto
  String t = 42.toString();
  String moneda = 9.5.toStringAsFixed(2); // '9.50'

  // Entre numéricos
  double d = 7.toDouble();     // 7.0
  int i = 7.9.toInt();         // 7 (trunca)

  print('"$t" "$moneda" $d $i');
}

void main() {
  bool activo = true;
  bool mayorEdad = 21 >= 18;

  // if (activo) ... correcto
  // if (1) ...       ERROR: conditions must have a static type of 'bool'

  print(activo && mayorEdad); // AND lógico: true
  print(!activo);             // NOT lógico: false
}

void main() {
  var a = 'comillas simples';
  var b = "o dobles";              // equivalentes

  var escape = 'Ruta: C:\\temp\nSalto de línea\tTabulación';
  print(escape);

  var multilinea = '''
Querido diario:
  hoy aprendí Dart.
''';                              // respeta saltos y sangrías
  print(multilinea);

  var cruda = r'C:\nueva_carpeta\tabla'; // raw: \n NO es salto de línea
  print(cruda);

  var adyacente = 'texto en '
      'varias líneas '
      'sin símbolos raros';
  print(adyacente);
}

void main() {
  var nombre = 'Ana';
  int edad = 34;

  print('Me llamo $nombre');                 // variable directa
  print('El próximo año tendré ${edad + 1}'); // expresión entre llaves
  print('Objeto: ${[1, 2, 3]}');             // cualquier objeto
  print(r'Sin interpolar: $nombre');         // cruda no interpola
}

void main() {
  var frase = '  Aprendiendo Dart paso a paso  ';

  print(frase.trim());            // quita espacios extremos
  print(frase.trim().length);     // 28
  print(frase.isEmpty);           // false
  print(''.isEmpty);              // true

  var f = frase.trim().toLowerCase();

  print(f.contains('dart'));      // true
  print(f.startsWith('aprend'));  // true
  print(f.endsWith('paso'));      // true
  print(f.indexOf('Dart'.toLowerCase())); // 12 (posición)

  print(f.substring(12, 16));     // 'dart'
  print(f.split(' '));            // ['aprendiendo', 'dart', 'paso', 'a', 'paso']
  print(f.replaceAll('paso', 'nivel'));
  print(f.replaceFirst('a', 'A')); // solo la primera aparición

  var codigo = '42';
  print(codigo.padLeft(5, '0'));  // '00042'
  print('*'.padRight(5, '-'));    // '*----'
}

void main() {
  var a = 'hola';
  var b = 'ho' + 'la';

  print(a == b);           // true: compara CONTENIDO
  print(a.compareTo(b));   // 0: iguales; negativo si va antes, positivo si después

  var lista = ['pera', 'manzana', 'kiwi'];
  lista.sort();
  print(lista);            // orden lexicográfico
}

void main() {
  // FINAL: valor único, decidido al ejecutarse
  final ahora = DateTime.now();     // correcto: se evalúa en ejecución
  print(ahora.year);

  // CONST: debe poder calcularse al compilar
  const pi = 3.14159;
  const diasSemana = ['lunes', 'martes']; // colección inmutable profunda
  print('$pi - $diasSemana');
}

void main() {
  final listaFinal = [1, 2, 3];
  listaFinal.add(4);        // PERFECTO: la referencia es final, no el contenido
  print(listaFinal);

  const listaConst = [1, 2, 3];
  // listaConst.add(4);     // ERROR en tiempo de ejecución:
  // Unsupported operation: Cannot add to an unmodifiable list
  print(listaConst);

  var normal = [1, 2];
  normal.add(3);            // var también es modificable
  print(normal);
}

const segundosPorDia = 60 * 60 * 24;      // el compilador lo calcula
const minutosPorAnio = segundosPorDia / 60; // puede basarse en otras const

void main() {
  print(segundosPorDia);   // 86400
  print(minutosPorAnio);   // 1440.0

  // Dos listas const idénticas SON EL MISMO objeto en memoria:
  const a = [1, 2];
  const b = [1, 2];
  print(identical(a, b));  // true (canonicalización)
}

void main() {
  var x = 10;
  x += 5;   print(x);   // 15   (equivale a x = x + 5)
  x -= 3;   print(x);   // 12
  x *= 2;   print(x);   // 24
  x ~/= 5;  print(x);   // 4    (división entera con asignación)
  x %= 3;   print(x);   // 1

  var n = 5;
  print(n++);  // 5  -> devuelve ANTES de incrementar (post-incremento)
  print(n);    // 6
  print(++n);  // 7  -> incrementa ANTES de devolver (pre-incremento)
  print(-n);   // -7 (unario negativo)
}

void main() {
  var edad = 25;

  print(edad == 25);  // true   igualdad de VALOR
  print(edad != 30);  // true
  print(edad >= 18 && edad < 65); // AND lógico: true
  print(edad < 18 || edad > 64);  // OR lógico: false

  String? nombre;                 // puede ser null (capítulo 17)
  print(identical('a', 'a'));     // identidad de objetos (misma memoria)

  // == compara valor (para strings, números...); las clases pueden redefinirlo
  print([1, 2] == [1, 2]);        // false: dos listas distintas en memoria
}

void main() {
  var nota = 8;
  var resultado = nota >= 5 ? 'aprobado' : 'suspenso';
  print(resultado);

  var estado = nota >= 9
      ? 'excelente'
      : nota >= 5
          ? 'aprobado'
          : 'suspenso';
  print(estado);
}

Object valor = 'tengo 42 años';

void main() {
  print(valor is String);       // true
  print(valor is! int);         // true (no es int)
  print(valor.length);          // 14

  if (valor is String) {
    // Dentro del if, 'valor' ya se sabe String: autocompletado completo
    print(valor.toUpperCase());
  }
}

void main() {
  print(5 & 3);   // 1  AND bit a bit  (0101 & 0011)
  print(5 | 3);   // 7  OR bit a bit   (0101 | 0011)
  print(5 ^ 3);   // 6  XOR bit a bit
  print(~5);      // -6 complemento
  print(1 << 3);  // 8  desplazar bits a la izquierda
  print(16 >> 2); // 4  desplazar a la derecha
  print(8 >>> 2); // 2  desplazamiento sin signo (Dart 2.14+)
}

void main() {
  int temperatura = 31;

  if (temperatura >= 30) {
    print('Hace calor');
  } else if (temperatura >= 15) {
    print('Templado');
  } else {
    print('Frío');
  }
}

void main() {
  const dia = 'sabado';

  switch (dia) {
    case 'lunes':
    case 'martes':            // casos vacíos caen juntos: agrupar es gratis
      print('Inicio de semana');
      break;                  // obligatorio: evita la caída accidental entre casos
    case 'sabado':
    case 'domingo':
      print('Fin de semana');
      break;
    default:
      print('Entre semana');
  }
}

String saludo(String idioma) => switch (idioma) {
      'es' => '¡Hola!',
      'en' => 'Hello!',
      'fr' => 'Bonjour !',
      _    => 'Idioma no soportado', // _: comodín por defecto
    };

void main() {
  print(saludo('es'));
  print(saludo('en'));
  print(saludo('jp'));

  // También admite rangos combinando patrones (adelanto del capítulo 30):
  String nota(int puntos) => switch (puntos) {
        >= 90 => 'Sobresaliente',
        >= 60 => 'Aprobado',
        _     => 'Insuficiente',
      };
  print(nota(95));
}

void main() {
  final respuestas = [42];

  // Comprueba forma Y valor a la vez:
  if (respuestas case [int n] when n == 42) {
    print('La respuesta a todo: $n');
  }
}

void main() {
  for (var i = 1; i <= 3; i++) {
    print('Vuelta número $i');
  }

  // Tabla de multiplicar anidada:
  for (var fila = 1; fila <= 2; fila++) {
    var linea = '';
    for (var col = 1; col <= 3; col++) {
      linea += '${fila * col}\t';
    }
    print(linea);
  }
}

void main() {
  var frutas = ['kiwi', 'pera', 'uva'];

  for (var fruta in frutas) {
    print(fruta);
  }

  // Con índice cuando lo necesitas:
  var letras = 'dart'.split('');
  for (var i = 0; i < letras.length; i++) {
    print('$i: ${letras[i]}');
  }
}

void main() {
  var saldo = 100;

  while (saldo >= 30) {       // comprueba ANTES de entrar
    saldo -= 30;
    print('Compra realizada. Saldo: $saldo');
  }
  print('Saldo insuficiente');

  var intentos = 0;
  do {                        // ejecuta AL MENOS una vez
    intentos++;
    print('Intento $intentos');
  } while (intentos < 3);
}

void main() {
  for (var i = 1; i <= 5; i++) {
    if (i == 4) break;         // abandona el bucle entero
    if (i % 2 == 0) continue;  // salta esta iteración
    print(i);
  }

  // Etiquetas para saltar en bucles anidados (uso puntual):
  exterior:
  for (var f = 1; f <= 3; f++) {
    for (var c = 1; c <= 3; c++) {
      if (f * c == 6) break exterior;
      print('$f-$c');
    }
  }
}

// tipoRetorno nombre(parámetros) { cuerpo }
int sumar(int a, int b) {
  return a + b;
}

void main() {
  var total = sumar(2, 3);
  print('Total: $total');

  saludar('Ana');          // llamar sin usar su retorno es válido si devuelve algo útil
}

// void = no devuelve nada; return opcional o vacío
void saludar(String nombre) {
  print('Hola, $nombre');
  // return; // implícito
}

int duplicar(int n) => n * 2;

bool esPar(int n) => n % 2 == 0;

String estado(int edad) => edad >= 18 ? 'adulto' : 'menor';

void main() {
  print(duplicar(21));   // 42
  print(esPar(21));      // false
  print(estado(21));     // adulto
}

// Sin tipos compila en modo dinámico antiguo, pero hoy el analizador avisa:
double area(double base, double altura) => base * altura / 2;

void main() {
  print(area(10, 4));   // 20.0
}

String ficha(String nombre, [int? edad, String ciudad = 'Desconocida']) {
  var e = edad == null ? '?' : '$edad';
  return '$nombre ($e años) vive en $ciudad';
}

void main() {
  print(ficha('Ana'));
  print(ficha('Ana', 34));
  print(ficha('Ana', 34, 'Madrid'));
}

Usuario crearUsuario({
  required String nombre,       // required = obligatorio
  int edad = 18,                // con valor por defecto
  bool activo = true,
}) => Usuario(nombre, edad, activo);

class Usuario {
  final String nombre;
  final int edad;
  final bool activo;
  Usuario(this.nombre, this.edad, this.activo);

  @override
  String toString() => 'Usuario($nombre, $edad, activo: $activo)';
}

void main() {
  print(crearUsuario(nombre: 'Luis'));
  print(crearUsuario(nombre: 'Marta', edad: 41, activo: false));

  // El orden ya no importa: se llama por nombre
  print(crearUsuario(activo: false, nombre: 'Beto'));
}

void reporte(String titulo, {int nivel = 1, List<String>? notas}) {
  print('$titulo (nivel $nivel)');
  if (notas != null) {
    for (var nota in notas) {
      print(' - $nota');
    }
  }
}

void main() {
  reporte('Ventas');
  reporte('Incidencias', nivel: 3);
  reporte('Auditoría', nivel: 2, notas: ['Sin hallazgos', 'OK']);
}

void main() {
  // Sin nombre, asignada a una variable:
  var sumar = (int a, int b) => a + b;
  print(sumar(2, 5)); // 7

  // Cuerpo largo con llaves y return:
  var clasificar = (int edad) {
    if (edad < 13) return 'niño';
    if (edad < 18) return 'adolescente';
    return 'adulto';
  };
  print(clasificar(15)); // adolescente

  // Uso típico: callback dentro de un método de colección
  ['a', 'b', 'c'].forEach((letra) {
    print('Letra: $letra');
  });
}

void ejecutarSi(bool condicion, void Function() accion) {
  if (condicion) {
    accion();
  }
}

int aplicarOperacion(int x, int Function(int) operacion) {
  return operacion(x);
}

void main() {
  ejecutarSi(10 > 5, () => print('La condición era verdadera'));

  print(aplicarOperacion(6, (n) => n * n));       // 36
  print(aplicarOperacion(6, (n) => n + 100));     // 106
}

// Devuelve una función nueva que multiplica por 'factor'
Function crearMultiplicador(int factor) {
  return (int n) => n * factor;   // recuerda 'factor' para siempre
}

void main() {
  final duplicar = crearMultiplicador(2);
  final triplicar = crearMultiplicador(3);

  print(duplicar(10));   // 20  -> recuerda factor=2
  print(triplicar(10));  // 30  -> recuerda factor=3

  // Contador con estado privado gracias al closure:
  var contador = crearContador();
  print(contador()); // 1
  print(contador()); // 2
  print(contador()); // 3
}

Function crearContador() {
  int cuenta = 0;                 // vive mientras exista la función devuelta
  return () => ++cuenta;
}

// Un alias reutilizable y autodocumentado:
typedef Comparador<T> = int Function(T a, T b);
typedef Procesador = String Function(String entrada);

String normalizar(String s) => s.trim().toLowerCase();

void main() {
  final Procesador p = normalizar;
  print(p('   HOLA MUNDO   '));

  List<int> edades = [40, 12, 25];
  edades.sort((a, b) => a.compareTo(b)); // Comparador<int> en línea
  print(edades);
}

void main() {
  var tareas = ['comprar', 'estudiar'];   // List<String> por inferencia
  List<int> primos = [2, 3, 5, 7];

  tareas.add('descansar');       // añade al final
  tareas.insert(0, 'despertar'); // inserta en posición
  print(tareas);

  print(tareas.length);          // 4
  print(tareas[0]);              // despertar (acceso por índice)
  tareas[0] = 'levantarse';      // reemplazar

  print(tareas.contains('estudiar')); // true
  print(tareas.indexOf('descansar')); // 3

  tareas.removeAt(0);            // elimina por índice y lo devuelve
  tareas.remove('estudiar');     // elimina el primer igual
  print(tareas);

  print(primos.reversed);        // (7, 5, 3, 2) vista invertida
  print(primos.sublist(1, 3));   // [3, 5]
  print(primos.take(2));         // (2, 3) primeros dos
  print(primos.skip(1).take(2)); // (3, 5) salta uno y toma dos

  var vacia = <String>[];        // lista vacía tipada explícita
  print(vacia.isEmpty);
}

void main() {
  var numeros = [40, 12, 25, 8];
  numeros.sort();                       // ascendente in situ
  print(numeros);

  numeros.sort((a, b) => b.compareTo(a)); // descendente con comparador
  print(numeros);

  var nombres = ['carla', 'Ana', 'bruno'];
  nombres.sort((a, b) => a.toLowerCase().compareTo(b.toLowerCase()));
  print(nombres);                       // orden alfabético insensible a mayúsculas
}

void main() {
  var edades = [12, 17, 34, 41, 9];

  var adultos = edades.where((e) => e >= 18);     // filtra
  print(adultos.toList());

  var enAnios = edades.map((e) => '$e años');     // transforma cada elemento
  print(enAnios.join(', '));

  print(edades.any((e) => e > 40));   // true  ¿alguno cumple?
  print(edades.every((e) => e > 5));  // true  ¿cumplen todos?
  print(edades.firstWhere((e) => e >= 18, orElse: () => -1)); // primer adulto

  var suma = edades.reduce((a, b) => a + b);      // acumula sin valor inicial
  var total = edades.fold<int>(0, (a, b) => a + b); // con valor inicial y tipo
  print('$suma $total');

  var pares = edades.expand((e) => [e, e * 10]);  // aplana resultados
  print(pares);
}

void main() {
  var base = [1, 2];
  var completa = [...base, 3, 4];         // ... expande otra colección
  print(completa);

  List<int>? posibleNull;
  var segura = [...?posibleNull, 99];     // ...? ignora si es null
  print(segura);

  bool modoAdmin = true;
  final menu = [
    'Inicio',
    if (modoAdmin) 'Panel de administración',   // elemento condicional
    for (var i = 1; i <= 3; i++) 'Sección $i',  // elementos generados
  ];
  print(menu);
}

void main() {
  var visitados = <String>{'Madrid', 'Lima'};
  visitados.add('Bogotá');
  visitados.add('Madrid');        // duplicado: ignorado silenciosamente
  print(visitados);
  print(visitados.length);        // 3

  print(visitados.contains('Lima')); // búsqueda O(1), muy rápida

  var europeas = {'Madrid', 'París'};
  print(visitados.union(europeas));
  print(visitados.intersection(europeas));
  print(visitados.difference(europeas));

  // Truco clásico: eliminar duplicados de una lista
  var conRepetidos = ['a', 'b', 'a', 'c', 'b'];
  var unicos = conRepetidos.toSet().toList();
  print(unicos);
}

void main() {
  var capitales = {
    'España': 'Madrid',
    'Perú': 'Lima',
  };
  capitales['Colombia'] = 'Bogotá';   // añadir o actualizar

  print(capitales['Perú']);           // Lima
  print(capitales['Francia']);        // null (clave inexistente)
  print(capitales['Francia'] ?? 'Sin dato');

  print(capitales.containsKey('España'));
  print(capitales.containsValue('Lima'));
  print(capitales.length);

  capitales.putIfAbsent('Chile', () => 'Santiago');
  capitales.update('España', (capital) => capital.toUpperCase());
  print(capitales);

  capitales.remove('Chile');
  print(capitales.keys);
  print(capitales.values);
}

void main() {
  var inventario = {'manzanas': 12, 'peras': 5};

  inventario.forEach((producto, cantidad) {
    print('$producto: $cantidad uds.');
  });

  for (final entrada in inventario.entries) {
    print('${entrada.key} => ${entrada.value}');
  }

  // Transformar un mapa en otro:
  final agotados = inventario.map((k, v) => MapEntry(k, v < 6 ? 'agotándose' : 'ok'));
  print(agotados);

  // Mapas con claves dinámicas (JSON crudo):
  dynamic respuesta = {'id': 7, 'nombre': 'Ada'};
  print(respuesta['nombre']);
}

void main() {
  const baseConfig = {'tema': 'claro', 'idioma': 'es'};
  final configUsuario = {
    ...baseConfig,
    'notificaciones': true,
    if (!baseConfig.containsKey('fuente')) 'fuente': 'Roboto',
  };
  print(configUsuario);
}

void main() {
  String nombre = 'Ada';    // NO puede ser null jamás
  // nombre = null;         // ERROR de compilación

  String? apodo;            // String? SÍ puede ser null
  print(apodo);             // null
  print(apodo?.length);     // null: llamada segura

  apodo = 'la primera';
  print(apodo.length);      // ahora sin ? : el compilador sabe que no es null aquí
}

String? obtenerApodo(String usuario) =>
    usuario == 'ada' ? 'la primera' : null;

void main() {
  var apodo = obtenerApodo('ada');

  print(apodo ?? 'sin apodo');     // si es null, usa el valor de la derecha
  print(obtenerApodo('bob') ?? 'sin apodo');

  int visitas = 0;
  visitas ??= 1;                   // asigna SOLO si era null
  print(visitas);                  // 0 (no era null)

  int? otra;
  otra ??= 7;
  print(otra);                     // 7

  // Encadenado seguro: corta toda la cadena al primer null
  Map<String, dynamic>? respuesta;
  print(respuesta?['usuario']?['email']);
}

void main() {
  String? texto = '42';

  // Convierte un String? en String asumiendo que no es null:
  int numero = int.parse(texto!);
  print(numero + 8);   // 50

  // ¡CUIDADO! Si fuera null lanza excepción en tiempo de ejecución:
  String? vacio;
  // print(vacio!.length); // Null check operator used on a null value
}

void main() {
  String? nombre;

  if (nombre != null) {
    // Dentro del if, nombre se PROMOCIONA a String:
    print(nombre.toUpperCase());
  }

  nombre = 'Ana';
  // Tras la asignación, también está promovido:
  print(nombre.length);
}

class Configuracion {
  // Se declara sin valor pero se garantiza su asignación antes de usarse:
  late final String apiKey;

  void cargar() {
    apiKey = 'sk-1234';   // única asignación permitida por final
  }

  void usar() {
    cargar();
    print(apiKey);        // seguro: ya fue cargada
  }
}

// late también permite inicialización perezosa a nivel local:
late String costoso = calcularCostoso();
String calcularCostoso() {
  print('Calculando…');       // solo se ejecuta en el PRIMER acceso
  return 'resultado';
}

void main() {
  final c = Configuracion()..usar();  // cascada: capítulo 20
  print(c.runtimeType);
  print(costoso);
}

class Coche {
  // Campos (estado)
  String marca;
  String modelo;
  int anio;

  // Constructor: inicializa el estado
  Coche(this.marca, this.modelo, this.anio);

  // Método (comportamiento)
  String descripcion() => '$marca $modelo ($anio)';

  int edad() => DateTime.now().year - anio;
}

void main() {
  var miCoche = Coche('Toyota', 'Corolla', 2021);  // instancia 1
  var otroCoche = Coche('Seat', 'Ibiza', 2024);    // instancia 2 independiente

  print(miCoche.descripcion());
  print('Edad del Toyota: ${miCoche.edad()} años');
  print(otroCoche.descripcion());

  // Los campos son accesibles y modificables:
  miCoche.anio = 2020;
  print(miCoche.descripcion());
}

class Punto {
  double x;
  double y;

  // Forma larga:
  // Punto(double x, double y) { this.x = x; this.y = y; }

  // Forma idiomática (initializing formal): this.x asigna directo
  Punto(this.x, this.y);

  double distanciaAlOrigen() {
    var dx = -x;   // dentro de la clase no hace falta this.
    var dy = -y;
    return sqrt(dx * dx + dy * dy);
  }
}

// Necesitamos dart:math para sqrt — así se importa una librería:
import 'dart:math';

void main() {
  final p = Punto(3, 4);
  print(p.distanciaAlOrigen()); // 5.0 (¡el famoso triángulo!)
}

class Libro {
  String titulo;
  String autor;

  Libro(this.titulo, this.autor);

  @override                       // indica que reemplazamos un método heredado
  String toString() => '"$titulo" de $autor';
}

void main() {
  var l = Libro('1984', 'Orwell');
  print(l);            // print llama a toString automáticamente
  print('${l}');       // igual en interpolación
}

class Tarea {
  final String titulo;
  final String prioridad;
  final bool completada;

  Tarea(
    this.titulo, {
    this.prioridad = 'media',     // nombrados con valor por defecto
    this.completada = false,
  });

  @override
  String toString() => '[$prioridad] $titulo ${completada ? "OK" : ""}';
}

void main() {
  print(Tarea('Pagar alquiler'));
  print(Tarea('Estudiar Dart', prioridad: 'alta'));
  print(Tarea('Comprar pan', prioridad: 'baja', completada: true));
}

class Rectangulo {
  final double ancho;
  final double alto;
  late final double area;   // calculada una sola vez

  Rectangulo(this.ancho, this.alto)
      : area = ancho * alto {         // ANTES del cuerpo: campos derivados/finales
    print('Rectángulo creado');
  }
}

void main() => print(Rectangulo(3, 4).area);

import 'dart:convert';

class Punto {
  final double x, y;
  Punto(this.x, this.y);

  // Constructor alternativo: origen fijo
  Punto.origen()
      : x = 0,
        y = 0;

  // Desde JSON:
  Punto.desdeJson(String json)
      : this._desdeMapa(jsonDecode(json));

  Punto.polar(double radio, double angulo)
      : x = radio * cos(angulo),
        y = radio * sin(angulo);

  Punto._desdeMapa(Map<String, dynamic> m)
      : x = m['x'],
        y = m['y'];

  @override
  String toString() => '($x, $y)';
}

void main() {
  print(Punto(1, 2));
  print(Punto.origen());
  print(Punto.polar(2, 0));                 // (2.0, ~0.0)
  print(Punto.desdeJson('{"x": 5, "y": 7}'));
}

class Pizza {
  String tamano;
  Pizza(this.tamano);
  Pizza.grande() : this('grande');       // delega en el principal
  Pizza.familiar() : this('familiar + borde');
}

void main() {
  print(Pizza.familiar().tamano);
}

class Logger {
  static final Map<String, Logger> _cache = {};

  final String nombre;
  Logger._interno(this.nombre);

  factory Logger(String nombre) {
    return _cache.putIfAbsent(nombre, () => Logger._interno(nombre));
  }
}

void main() {
  var a = Logger('api');
  var b = Logger('api');
  print(identical(a, b));   // true: mismo objeto devuelto (patrón Singleton)
}

class Etiqueta {
  final String texto;
  const Etiqueta(this.texto);
}

void main() {
  const e1 = Etiqueta('FRAGIL');
  const e2 = Etiqueta('FRAGIL');
  var e3 = Etiqueta('FRAGIL');

  print(identical(e1, e2));  // true: compiladas como un único objeto
  print(identical(e1, e3));  // false: e3 no fue declarada const
}

class CuentaBancaria {
  double _saldo = 0;          // _privado a nivel de biblioteca

  // Getter: se lee como propiedad, no como método
  double get saldo => _saldo;

  // Setter con validación
  set saldo(double valor) {
    if (valor < 0) {
      throw ArgumentError('El saldo no puede ser negativo');
    }
    _saldo = valor;
  }

  void depositar(double monto) => _saldo += monto;
}

void main() {
  final c = CuentaBancaria();
  c.depositar(100);
  print(c.saldo);      // sin paréntesis: parece un campo…
  c.saldo = 150;       // …pero pasa por el setter validado
  print(c.saldo);
}

class Matematica {
  static const double pi = 3.14159;

  static int cuadrado(int n) => n * n;

  static int _instancias = 0;
  static int get instancias => _instancias;
}

class Producto {
  static int totalCreados = 0;   // contador compartido por TODAS las instancias
  Producto() {
    totalCreados++;
  }
}

void main() {
  print(Matematica.pi);          // sin crear objetos
  print(Matematica.cuadrado(9));

  Producto(); Producto(); Producto();
  print(Producto.totalCreados);
}

class Dinero {
  final double monto;
  const Dinero(this.monto);

  // Permite escribir dineroA + dineroB
  Dinero operator +(Dinero otro) => Dinero(monto + otro.monto);

  @override
  bool operator ==(Object other) =>
      other is Dinero && other.monto == monto;

  @override
  int get hashCode => monto.hashCode;

  @override
  String toString() => '${monto.toStringAsFixed(2)} €';
}

void main() {
  const cafe = Dinero(1.5);
  const croissant = Dinero(2.25);
  print(cafe + croissant);

  const a = Dinero(10), b = Dinero(10);
  print(a == b);          // true: definimos igualdad por valor
  print(a.hashCode == b.hashCode); // coherente con ==
}

class Corrector {
  final double tolerancia;
  Corrector(this.tolerancia);

  // El objeto ahora «se llama» como una función:
  bool call(double esperado, double obtenido) =>
      (esperado - obtenido).abs() <= tolerancia;
}

void main() {
  final corrige = Corrector(0.01);
  print(corrige(10, 9.995));   // true — ¡un objeto usado como función!
  print(corrige(10, 9.8));     // false
}

class Animal {
  String nombre;
  Animal(this.nombre);

  void hacerSonido() => print('$nombre hace un sonido genérico');
  void dormir() => print('$nombre duerme… zzz');
}

class Perro extends Animal {
  Perro(String nombre) : super(nombre);   // llama al constructor del padre

  @override
  void hacerSonido() => print('$nombre dice ¡guau!');

  void traerPalo() => print('$nombre trae el palo');
}

void main() {
  var animal = Animal('Criatura');
  var perro = Perro('Rex');

  animal.hacerSonido();
  perro.hacerSonido();   // versión redefinida (polimorfismo)
  perro.dormir();        // heredado intacto
  perro.traerPalo();     // propio de Perro
}

class Gato extends Animal {
  Gato(String nombre) : super(nombre);
  @override
  void hacerSonido() => print('$nombre dice miau');
}

void main() {
  List<Animal> granja = [Perro('Rex'), Gato('Michi'), Animal('Oveja')];

  for (final a in granja) {
    a.hacerSonido();       // cada uno responde a SU manera
  }
}

class Empleado {
  String nombre;
  double salarioBase;
  Empleado(this.nombre, this.salarioBase);

  double salarioTotal() => salarioBase;
  String ficha() => 'Empleado: $nombre';
}

class Gerente extends Empleado {
  double bono;
  Gerente(String nombre, double base, this.bono) : super(nombre, base);

  @override
  double salarioTotal() => super.salarioTotal() + bono;  // extiende, no sustituye

  @override
  String ficha() => '${super.ficha()} (Gerente)';
}

void main() {
  var g = Gerente('Ana', 2000, 500);
  print(g.salarioTotal());
  print(g.ficha());
}

class Vehiculo {
  final String ruedas;
  Vehiculo(this.ruedas) { print('Vehículo($ruedas)'); }
}

class Moto extends Vehiculo {
  Moto() : super('2 ruedas') { print('Moto lista'); }
}

void main() => Moto();
// El constructor del PADRE siempre se ejecuta primero.

abstract class Figura {
  String nombre;

  Figura(this.nombre);

  double area();              // método abstracto: SIN cuerpo

  void describir() {          // implementación compartida
    print('$nombre tiene un área de ${area().toStringAsFixed(2)}');
  }
}

class Circulo extends Figura {
  double radio;
  Circulo(this.radio) : super('Círculo');

  @override
  double area() => 3.14159 * radio * radio;
}

class Cuadrado extends Figura {
  double lado;
  Cuadrado(this.lado) : super('Cuadrado');

  @override
  double area() => lado * lado;
}

void main() {
  // var f = Figura('x');  // ERROR: las clases abstractas no se instancian
  List<Figura> figuras = [Circulo(1), Cuadrado(3)];
  for (final f in figuras) {
    f.describir();
  }
}

class Repositorio {
  String nombre = 'base';
  void guardar(String dato) => print('[$nombre] guardando $dato');
}

class RepositorioMemoria implements Repositorio {
  @override
  String nombre = 'memoria';

  final _datos = <String>[];

  @override
  void guardar(String dato) => _datos.add(dato);   // reimplementado al 100%

  List<String> get datos => List.unmodifiable(_datos);
}

void main() {
  var repo = RepositorioMemoria();
  repo.guardar('tarea 1');
  print(repo.datos);
}

// Contrato clásico estilo interfaz:
abstract class Notificable {
  void notificar(String mensaje);
}

class EmailService implements Notificable {
  @override
  void notificar(String mensaje) => print('Email: $mensaje');
}

class SmsService implements Notificable {
  @override
  void notificar(String mensaje) => print('SMS: $mensaje');
}

// Programamos contra el CONTRATO, no contra clases concretas:
void avisar(Notificable canal, String msg) => canal.notificar(msg);

void main() {
  avisar(EmailService(), 'Tu pedido salió');
  avisar(SmsService(), 'Código: 123456');
}

mixin Volador {
  void volar() => print('Volando…');
}

mixin Nadador {
  void nadar() => print('Nadando…');
}

class Pato extends Animal with Volador, Nadador {
  Pato(String nombre) : super(nombre);
}

class Pez extends Animal with Nadador {
  Pez(String nombre) : super(nombre);
}

class Animal {
  String nombre;
  Animal(this.nombre);
  void hacerSonido() => print('$nombre hace sonido');
}

void main() {
  var pato = Pato('Donald');
  pato.hacerSonido();   // del padre
  pato.volar();         // del mixin Volador
  pato.nadar();         // del mixin Nadador

  Pez('Nemo').nadar();
  // Nemo.volar();      // ERROR: Pez no mezcla Volador
}

mixin Logger {
  void log(String msg) => print('[LOG] $msg');
}

mixin Timestamped {
  DateTime get creadoEn => DateTime.now();
}

class Pedido with Logger, Timestamped {
  String producto;
  Pedido(this.producto);

  void confirmar() {
    log('Pedido "$producto" confirmado a las ${creadoEn.toIso8601String()}');
  }
}

void main() => Pedido('Teclado mecánico').confirmar();

mixin Caminante {
  void moverse() => print('Camino');
}

mixin Corredor {
  void moverse() => print('Corro');
}

class Persona with Caminante, Corredor {}   // ¡el último gana!

void main() => Persona().moverse();         // Corro

abstract class Vehiculo {
  int km = 0;
  void rodar() => km += 10;
}

// Solo puede mezclarse EN clases Vehiculo o hijas:
mixin Turbo on Vehiculo {
  void activarTurbo() {
    rodar();            // garantizado: existe porque venimos de Vehiculo
    km += 90;
    print('¡Turbo! Total km: $km');
  }
}

class CocheDeportivo extends Vehiculo with Turbo {}

void main() => CocheDeportivo().activarTurbo();

// Puede usarse como mixin (with) Y como clase padre (extends):
mixin class Utilidades {
  int doble(int n) => n * 2;
}

class Calculadora with Utilidades {}
void main() => print(Calculadora().doble(21)); // 42

enum Estado { pendiente, enviando, entregado }

void main() {
  var e = Estado.enviando;

  print(e.name);          // 'enviando'
  print(e.index);         // 1
  print(Estado.values);   // lista con todos los casos
  print(Estado.values.length);

  final porNombre = Estado.values.byName('entregado');
  print(porNombre);
}

String iconoDe(Estado estado) => switch (estado) {
      Estado.pendiente => 'reloj',
      Estado.enviando => 'camion',
      Estado.entregado => 'check',
    };
// Si mañana añades un caso al enum y olvidas esta función,
// el COMPILADOR marca el error antes de ejecutar nada.

void main() {
  for (final e in Estado.values) {
    print('${e.name} -> ${iconoDe(e)}');
  }
}

// Cada caso puede llevar datos y comportamiento propio:
enum Planeta {
  mercurio(0.39),
  tierra(1.00),
  marte(1.52);

  // Campos y constructor CONSTANTES obligatorios:
  final double distanciaSolUA;
  const Planeta(this.distanciaSolUA);

  double anosLuzARecorrer(int anios) => distanciaSolUA * anios;

  bool get esInterior => distanciaSolUA < 1;
}

void main() {
  print(Planeta.tierra.distanciaSolUA);   // 1.0
  print(Planeta.marte.esInterior);        // false
  print(Planeta.mercurio.anosLuzARecorrar ?? '');
}
// Nota: la última línea contiene una errata a propósito —
// corrígela a anosLuzARecorrer(10) para ver: 3.9

// Enum que implementa una interfaz:
abstract interface class Sonido {
  String get onomatopeya;
}

enum Animalito implements Sonido {
  gato('miau'),
  perro('guau');

  @override
  final String onomatopeya;
  const Animalito(this.onomatopeya);
}

void main() => print(Animalito.gato.onomatopeya); // miau

extension StringUtil on String {
  bool get esEmail => contains('@') && endsWith('.com');

  String capitalizar() =>
      isEmpty ? this : this[0].toUpperCase() + substring(1);

  String get invertida => split('').reversed.join();
}

extension IntUtil on int {
  int get enBytes => this * 1024 * 1024;   // MB a bytes
  bool get esPrimo {
    if (this < 2) return false;
    for (var i = 2; i * i <= this; i++) {
      if (this % i == 0) return false;
    }
    return true;
  }
}

void main() {
  print('hola@correo.com'.esEmail);
  print('ana'.capitalizar());
  print('dart'.invertida);
  print(500.enBytes);
  print([2, 4, 7].where((n) => n.esPrimo));
}

extension ListaX<T> on List<T> {
  T? segundoOrNull() => length >= 2 ? this[1] : null;

  List<T> sinDuplicados() => toSet().toList();

  void intercambiar(int i, int j) {
    if (i.isNegative || j.isNegative || j >= length || i >= length) return;
    final temp = this[i];
    this[i] = this[j];
    this[j] = temp;
  }
}

void main() {
  print(['a'].segundoOrNull());          // null, sin excepción
  print([1, 2, 2, 3].sinDuplicados());
}

extension A on String {
  String get saludo => 'Hola desde A';
}

extension B on String {
  String get saludo => 'Hola desde B';
}

void main() {
  var s = '';
  // print(s.saludo);           // AMBIGUO: error de compilación
  print(A(s).saludo);           // resuelto nombrando la extensión
  print(B(s).saludo);
}

extension type Metros(double valor) {
  Metros operator +(Metros otro) => Metros(valor + otro.valor);
  String get descripcion => '${valor}m';
}

extension type Pies(double valor) {}

void main() {
  var alto = Metros(1.8) + Metros(0.2);
  print(alto.descripcion);   // 2.0m
  print(alto.valor);         // acceso al representación interna

  // Metros m = Pies(6);      // ERROR: ¡tipos incompatibles en compilación!
  // Metros m = 1.8;          // ERROR: no se confunde con double
}

class Padre {
  void saludar() => print('Hola');
}

class Hijo extends Padre {
  @override                       // verifica que SÍ existe en el padre
  void saludar() => print('¡Hola!');

  // @override sobre un método inexistente = ERROR del analizador:
  // @override
  // void saludarr() {}            // The method doesn't override...
}

void main() {
  @Deprecated('Usa nuevaApi() en su lugar')
  void viejaApi() => print('vieja');

  viejaApi();   // el IDE tacha la llamada y muestra el mensaje
}

// Una anotación es una clase const normal:
class Ruta {
  final String path;
  final String metodo;
  const Ruta(this.path, {this.metodo = 'GET'});
}

enum Rol { admin, usuario }

class RequiereRol {
  final Rol rol;
  const RequiereRol(this.rol);
}

@Ruta('/usuarios', metodo: 'POST')
@RequiereRol(Rol.admin)
void crearUsuario() => print('Usuario creado');

void main() {
  crearUsuario();
  // Las anotaciones se leen con herramientas de análisis/generación de código,
  // no con reflexión (los mirrors no existen en Flutter por rendimiento).
}

class Caja<T> {
  T contenido;
  Caja(this.contenido);

  T abrir() => contenido;

  Caja<R> mapear<R>(R Function(T) transformar) => Caja(transformar(contenido));
}

void main() {
  final cajaTexto = Caja('regalo');
  print(cajaTexto.abrir().toUpperCase());   // sabe que es String

  final cajaNum = Caja(42);
  print(cajaNum.abrir() + 8);               // sabe que es int

  final cajaDoble = cajaNum.mapear((n) => n * 2);
  print(cajaDoble.abrir());
}

// T debe ser num o un subtipo: podemos sumar sin miedo
T sumaDeLista<T extends num>(List<T> valores) {
  T acumulado = valores.first;
  for (var i = 1; i < valores.length; i++) {
    acumulado = acumulado + valores[i] as T;
  }
  return acumulado;
}

void main() {
  print(sumaDeLista([1, 2, 3]));       // 6
  print(sumaDeLista([1.5, 2.5]));      // 4.0
  // print(sumaDeLista(['a']));        // ERROR: String no es num
}

void main() {
  var lista = <int>[1, 2, 3];

  // A diferencia de Java, aquí el tipo SÍ viaja hasta la ejecución:
  print(lista is List<int>);      // true
  print(lista is List<String>);   // false
  print(lista.runtimeType);       // List<int>

  // Por eso esto falla en runtime, no solo en análisis:
  List dinamicos = [1, 'dos'];
  if (dinamicos is List<String>) print(dinamicos.first.toUpperCase());
}

// Patrón muy usado en arquitecturas limpias y paquetes como fpdart:
sealed class Resultado<T> {}

class Exito<T> extends Resultado<T> {
  final T valor;
  Exito(this.valor);
}

class Fallo<T> extends Resultado<T> {
  final String error;
  Fallo(this.error);
}

Resultado<double> dividir(double a, double b) {
  if (b == 0) return Fallo('División por cero');
  return Exito(a / b);
}

void main() {
  for (final caso in [dividir(10, 2), dividir(10, 0)]) {
    switch (caso) {
      case Exito<double>(:final valor):
        print('OK: $valor');
      case Fallo<double>(:final error):
        print('ERROR: $error');
    }
  }
}

void main() {
  try {
    int.parse('no soy un número');
  } on FormatException {                 // captura UN tipo concreto, sin variable
    print('Formato inválido');
  }

  try {
    var lista = <int>[];
    lista.first;
  } on StateError catch (e) {            // tipo + objeto de error
    print('Error controlado: ${e.message}');
  }

  try {
    throw Exception('algo raro');
  } catch (e) {                          // captura CUALQUIER cosa lanzada
    print('Capturado: $e');
  } finally {
    print('finally SIEMPRE corre (cierres, logs…)');
  }
}

void nivelProfundo() => throw ArgumentError('valor prohibido');

void main() {
  try {
    nivelProfundo();
  } on ArgumentError catch (e, s) {   // segundo parámetro: StackTrace
    print('Mensaje: $e');
    print('Origen:');
    print(s.toString().split('\n').take(3).join('\n'));
  }
}

Future<String> descargar() async => throw Exception('red caída');

void main() async {
  try {
    await descargar();
  } catch (e) {
    print('Registrando en telemetría: $e');
    rethrow;   // vuelve a lanzar el MISMO error conservando el stack original
  }
}

class SaldoInsuficienteException implements Exception {
  final double faltante;
  SaldoInsuficienteException(this.faltante);

  @override
  String toString() => 'SaldoInsuficiente: faltan \$${faltante.toStringAsFixed(2)}';
}

void retirar(double saldo, double monto) {
  if (monto > saldo) {
    throw SaldoInsuficienteException(monto - saldo);
  }
  print('Retiro OK');
}

void main() {
  for (final monto in [50.0, 500.0]) {
    try {
      retirar(100, monto);
    } on SaldoInsuficienteException catch (e) {
      print(e);
    }
  }
}

double aplicarDescuento(double precio, double porcentaje) {
  assert(precio >= 0, 'El precio nunca puede ser negativo');
  assert(porcentaje >= 0 && porcentaje <= 100);
  return precio * (1 - porcentaje / 100);
}

void main() => print(aplicarDescuento(100, 15)); // 85.0
// En producción (dart compile) los asserts desaparecen: coste cero.

void main() {
  var par = (42, 'respuesta');          // Record de 2 campos
  print(par.$1);                        // 42   (posiciones desde $1)
  print(par.$2);                        // respuesta

  (int, String, bool) triple = (7, 'siete', true);  // tipado explícito
  print(triple);

  // Igualdad ESTRUCTURAL: por contenido, no por identidad
  var a = (1, 'x');
  var b = (1, 'x');
  print(a == b);            // true
  print(identical(a, b));   // false
}

(String, {int edad}) persona(String nombre, int anios) =>
    (nombre, edad: anios);

void main() {
  final ana = persona('Ana', 34);
  print(ana.$1);      // campo posicional
  print(ana.edad);    // campo nombrado

  // Mezcla permitida: posicionales primero, luego {nombrados}
  ({String titulo, List<double> notas}) boletin =
      (titulo: 'Matemáticas', notas: [4.5, 9.0]);
  print('${boletin.titulo}: ${boletin.notas}');
}

// Antes: clases contenedoras o parámetros mutables. Ahora:
(double minima, double maxima, double promedio) resumen(List<double> datos) {
  final ordenados = [...datos]..sort();
  return (
    ordenados.first,
    ordenados.last,
    datos.reduce((a, b) => a + b) / datos.length,
  );
}

void main() {
  final stats = resumen([3.5, 8.0, 5.5]);
  print('min ${stats.$1} | max ${stats.$2} | media ${stats.$3.toStringAsFixed(2)}');

  // Con destructuring directo a variables:
  final (min, max, promedio) = resumen([10, 20]);
  print('min $min max $max media $promedio');
}

String describir(Object valor) => switch (valor) {
      null                    => 'es nulo',              // patrón null
      0                       => 'cero',                 // literal
      int n when n < 0        => 'entero negativo: $n',  // variable + guardia when
      int()                   => 'entero positivo',      // object pattern vacío
      String s                => 'texto: $s',
      [_, _, ...]             => 'lista con 2+ elementos', // list pattern
      {'rol': String rol}     => 'mapa con rol=$rol',      // map pattern
      _                       => 'otra cosa',            // comodín
    };

void main() {
  for (final v in [null, 0, -5, 99, 'hola', ['a', 'b'], {'rol': 'admin'}, 3.14]) {
    print(describir(v));
  }
}

class Punto {
  final double x, y;
  const Punto(this.x, this.y);
}

String cuadrante(Punto p) => switch (p) {
      Punto(x: >= 0, y: >= 0) => 'I',      // patrones relacionales dentro del objeto
      Punto(x: < 0, y: >= 0)  => 'II',
      Punto(x: < 0, y: < 0)   => 'III',
      Punto(x: >= 0, y: < 0)  => 'IV',
      _                       => '?',
    };

void main() {
  for (final p in [Punto(1, 1), Punto(-2, 5), Punto(-1, -1), Punto(4, -9)]) {
    print(cuadrante(p));
  }

  // Extraer variables directamente:
  final Punto(x: px, y: py) = Punto(3, 4);   // destructuring declarativo
  print('px=$px py=$py');
}

void main() {
  // Lista exacta / prefijo / resto variable
  final [a, b] = [1, 2];
  final [primero, ...resto] = [1, 2, 3, 4];
  print('$a $b | primero=$primero resto=$resto');

  // Mapa: comprueba claves y captura valores
  final json = {'nombre': 'Ada', 'rol': 'dev'};
  final {'nombre': String nombre, 'rol': String rol} = json;
  print('$nombre es $rol');

  // Record anidado
  final (id, (nombre2, activo)) = (7, ('Luis', true));
  print('id=$id nombre=$nombre2 activo=$activo');
}

sealed class EstadoCarga {}

class Cargando extends EstadoCarga {}
class Exito extends EstadoCarga {
  final List<String> items;
  Exito(this.items);
}
class ErrorDeRed extends EstadoCarga {
  final String mensaje;
  ErrorDeRed(this.mensaje);
}

// SIN default: si mañana añades un estado nuevo, el compilador
// te obligará a manejarlo aquí. Eso es un superpoder.
String vista(EstadoCarga estado) => switch (estado) {
      Cargando()           => 'Mostrando spinner…',
      Exito(items: var it) => 'Lista: ${it.join(", ")}',
      ErrorDeRed(:final mensaje) => 'Fallo: $mensaje',
    };

void main() {
  for (final s in [Cargando(), Exito(['A', 'B']), ErrorDeRed('timeout')]) {
    print(vista(s));
  }
}

void main() {
  final respuestas = [200, 'OK'];

  if (respuestas case [int codigo, String texto] when codigo == 200) {
    print('HTTP $codigo ($texto)');
  }

  Object dato = 42;
  if (dato case int n when n.isEven) {
    print('par: $n');
  }
}

// Simulamos una llamada lenta:
Future<String> pedirNombreUsuario() async {
  await Future.delayed(const Duration(seconds: 1));   // espera sin bloquear
  return 'Ada';
}

// Estilo antiguo con callbacks (.then):
void main() {
  print('A');
  pedirNombreUsuario().then((nombre) => print('B: $nombre'));
  print('C');
}

Future<String> pedirNombreUsuario() async {
  await Future.delayed(const Duration(seconds: 1));
  return 'Ada';
}

// Estilo moderno: await pausa SOLO esta función, no toda la app
Future<void> main() async {
  print('A');
  final nombre = await pedirNombreUsuario();
  print('B: $nombre');
  print('C');
}

Future<int> descargar(String archivo) async {
  await Future.delayed(const Duration(seconds: 1));
  return archivo.length;
}

Future<void> main() async {
  var inicio = DateTime.now();

  // SECUENCIAL: uno tras otro (~2 s)
  final a = await descargar('a.json');
  final b = await descargar('b.json');

  // PARALELO: ambos a la vez (~1 s)
  final resultados = await Future.wait([
    descargar('c.json'),
    descargar('d.json'),
  ]);

  final total = DateTime.now().difference(inicio).inMilliseconds;
  print('$a $b ${resultados} en ~${total}ms');
}

Future<double> cotizacion(String moneda) async {
  await Future.delayed(const Duration(milliseconds: 300));
  if (moneda == 'BTC') throw Exception('cotización no disponible');
  return 1.08;
}

Future<void> main() async {
  try {
    final eur = await cotizacion('EUR');
    print('EUR: $eur');
    final btc = await cotizacion('BTC');
    print(btc);
  } catch (e) {
    print('Fallo: $e');
  } finally {
    print('Consulta terminada');
  }

  // Alternativa encadenada para APIs estilo callback:
  await cotizacion('BTC')
      .then((v) => print(v))
      .catchError((e) => print('catchError: $e'))
      .whenComplete(() => print('siempre'));
}

Future<void> main() async {
  try {
    final respuesta = await servicioLento().timeout(
      const Duration(seconds: 2),
      onTimeout: () => 'respuesta por defecto',
    );
    print(respuesta);
  } catch (e) {
    print(e);
  }
}

Future<String> servicioLento() async {
  await Future.delayed(const Duration(seconds: 5));
  return 'demasiado tarde';
}

Stream<int> segundos() async* {          // generator: capítulo siguiente
  for (var i = 1; i <= 3; i++) {
    await Future.delayed(const Duration(seconds: 1));
    yield i;
  }
}

void main() {
  final sub = segundos().listen(
    (valor) => print('Tick $valor'),      // cada dato recibido
    onDone: () => print('Stream terminado'),
    onError: (e) => print('Error: $e'),
  );

  // sub.cancel(); // detiene la escucha cuando quieras
}

Future<void> main() async {
  var suma = 0;
  await for (final n in segundos()) {   // pausa hasta que llega CADA valor
    suma += n;
    print('Acumulado: $suma');
  }
  print('Total: $suma');
}

Stream<String> descargarPorPartes(List<String> partes) async* {
  for (var i = 0; i < partes.length; i++) {
    await Future.delayed(const Duration(milliseconds: 200)); // trabajo lento
    yield 'parte ${i + 1}/${partes.length}: ${partes[i]}';
  }
}

Future<void> main() async {
  await for (final progreso in descargarPorPartes(['intro', 'cuerpo', 'fin'])) {
    print(progreso);
  }
}

// Delegación con yield*:
Stream<int> cuentaHasta(int n) async* {
  if (n >= 0) {
    yield n;
    yield* cuentaHasta(n - 1);   // reenvía todo el stream recursivo
  }
}

Iterable<int> naturales() sync* {
  var i = 1;
  while (true) {
    yield i++;                    // infinito… pero solo se calcula lo pedido
  }
}

void main() {
  final primeros5 = naturales().take(5).toList();
  print(primeros5);               // [1, 2, 3, 4, 5]

  Iterable<String> fibonaccis() sync* {
    int a = 0, b = 1;
    while (true) {
      yield '$a';
      [a, b] = [b, a + b];        // destructuring de records (capítulo 29)
    }
  }
  print(fibonaccis().take(8).toList());
}

import 'dart:async';

class Termometro {
  final _controlador = StreamController<double>();

  Stream<double> get temperaturas => _controlador.stream;

  void medir(double celsius) => _controlador.add(celsius);

  void cerrar() => _controlador.close();
}

void main() async {
  final t = Termometro();

  t.temperaturas
      .where((temp) => temp > 30)
      .map((temp) => 'ALERTA: ${temp}°C')
      .listen(print);

  t.medir(25);   // no pasa el filtro: silencio
  t.medir(33);
  await Future.delayed(Duration.zero);
  t.cerrar();
}

import 'dart:async';

void main() {
  print('1. síncrono');

  scheduleMicrotask(() => print('3. microtask'));

  Future(() => print('4. evento (Future)'));
  Future.delayed(Duration.zero, () => print('5. evento retrasado'));

  print('2. fin del síncrono');
}

// Cálculo CPU-intensivo que congelaría una UI:
int fibonacciLento(int n) {
  if (n < 2) return n;
  return fibonacciLento(n - 1) + fibonacciLento(n - 2);
}

Future<void> main() async {
  print('UI sigue fluida mientras calculo…');

  final resultado = await Isolate.run(() => fibonacciLento(30));

  print('fib(30) = $resultado');
}

import 'dart:async';
import 'dart:isolate';

// Cada isolate recibe UN mensaje inicial: usaremos un SendPort para dialogar.
void trabajador(SendPort canalHaciaMain) {
  final puerto = ReceivePort();
  canalHaciaMain.send(puerto.sendPort);   // entrego mi buzón

  puerto.listen((mensaje) {
    final numeros = mensaje as List<int>;
    final suma = numeros.reduce((a, b) => a + b);
    canalHaciaMain.send(suma);            // respondo
    puerto.close();                       // y termino
  });
}

Future<void> main() async {
  final canalDesdeMain = ReceivePort();
  await Isolate.spawn(trabajador, canalDesdeMain.sendPort);

  // Primer mensaje: el SendPort del trabajador
  final SendPort haciaTrabajador = await canalDesdeMain.first;

  // Segundo uso: sus respuestas. Redirijo con un StreamQueue manual simple:
  final respuestas = StreamIterator(canalDesdeMain);
  haciaTrabajador.send([1000000, 2000000, 3000000]);

  await respuestas.moveNext();
  print('Suma calculada en otro isolate: ${respuestas.current}');

  respuestas.cancel();
}

import 'dart:math';                    // SDK oficial (dart:)
import 'package:http/http.dart';       // paquete externo de pub.dev
import '../herramientas/utiles.dart';  // archivo propio relativo

// Control fino:
import 'dart:math' show max;           // solo trae max
import 'dart:convert' hide ascii;      // todo menos ascii
import 'package:intl/intl.dart' as intl; // prefijo para evitar choques

void main() {
  print(max(3, 7));
  print(intl.NumberFormat.currency(locale: 'es').format(1234.5));
}

name: mi_app
description: Una app de ejemplo.
version: 1.2.3+4        # versión semántica +build
environment:            # versiones mínimas del SDK
  sdk: ^3.5.0

dependencies:           # para producción
  http: ^1.2.0
  intl: any

dev_dependencies:       # solo desarrollo y pruebas
  lints: ^4.0.0
  test: ^1.24.0

// lib/mi_app.dart — el único archivo que otros deben importar:
export 'src/usuario.dart';
export 'src/repositorio.dart';

// En cualquier consumidor:
// import 'package:mi_app/mi_app.dart';   // limpio y estable

include: package:lints/recommended.yaml

analyzer:
  language:
    strict-casts: true
  errors:
    invalid_assignment: error

linter:
  rules:
    - prefer_final_locals
    - avoid_print        # avisa si imprimes sin querer en lib/
    - always_declare_return_types

void main() {
  final ahora = DateTime.now();
  final lanzamientoFlutter = DateTime(2015, 12, 4);

  print(lanzamientoFlutter.weekday);         // 5 (viernes)
  print(lanzamientoFlutter.isBefore(ahora)); // true

  final futuro = ahora.add(const Duration(days: 30));
  final diferencia = futuro.difference(ahora);

  print(diferencia.inDays);
  print(futuro.year);

  // Formato ISO 8601 (el estándar de las APIs):
  final iso = DateTime.parse('2026-08-22T10:30:00');
  print(iso.add(const Duration(hours: 8)).toIso8601String());
}

void main() {
  final telefono = RegExp(r'^\d{3}-\d{4}$');

  print(telefono.hasMatch('555-1234'));   // true
  print(telefono.hasMatch('abc'));        // false

  final palabras = RegExp(r'\w+');
  print(palabras.allMatches('Dart mola mucho').length);   // 3
  print('Hola mundo'.replaceAllMapped(
      RegExp(r'o'), (m) => '0'));                          // H0la mund0
}

import 'dart:convert';

class Producto {
  final int id;
  final String nombre;
  final double precio;

  Producto({required this.id, required this.nombre, required this.precio});

  // Deserialización manual: mapa -> objeto
  factory Producto.desdeJson(Map<String, dynamic> json) => Producto(
        id: json['id'] as int,
        nombre: json['nombre'] as String,
        precio: (json['precio'] as num).toDouble(),
      );

  // Serialización: objeto -> mapa
  Map<String, dynamic> aJson() =>
      {'id': id, 'nombre': nombre, 'precio': precio};

  @override
  String toString() => '$nombre ($precio€)';
}

void main() {
  const crudo = '{"id": 1, "nombre": "Teclado", "precio": 49.9}';

  final decodificado = jsonDecode(crudo) as Map<String, dynamic>;
  final producto = Producto.desdeJson(decodificado);
  print(producto);

  final listaJson = jsonEncode([producto.aJson()]);
  print(listaJson);
}

import 'dart:io';

Future<void> main(List<String> args) async {
  // Escribir y leer archivos:
  final notas = File('notas.txt');
  await notas.writeAsString('Primera línea\nSegunda línea\n');
  print(await notas.readAsString());

  // Añadir sin sobreescribir:
  await notas.writeAsString('Tercera\n', mode: FileMode.append);

  // Leer entrada del usuario (apps CLI):
  stdout.write('¿Tu nombre? ');
  final nombre = stdin.readLineSync();
  stdout.writeln('¡Hola, $nombre!');

  // Variables de entorno:
  print(Platform.environment['HOME'] ?? Platform.environment['USERPROFILE']);

  // Listar un directorio:
  await for (final entidad in Directory('.').list()) {
    if (entidad is File) print(entidad.path);
  }
}

int sumar(int a, int b) => a + b;

double dividir(int a, int b) {
  if (b == 0) throw ArgumentError('El divisor no puede ser cero');
  return a / b;
}

import 'package:test/test.dart';
import 'package:mi_app/calculadora.dart';

void main() {
  test('sumar devuelve la suma de dos enteros', () {
    final resultado = sumar(2, 3);
    expect(resultado, equals(5));
  });

  test('dividir lanza ArgumentError con divisor cero', () {
    expect(() => dividir(10, 0), throwsArgumentError);
  });

  test('dividir calcula el cociente real', () {
    expect(dividir(10, 4), closeTo(2.5, 0.0001));   // para doubles
  });
}

class Carrito {
  final items = <String>[];
  void agregar(String p) => items.add(p);
  void vaciar() => items.clear();
}

void main() {
  group('Carrito', () {
    late Carrito carrito;

    setUp(() => carrito = Carrito());       // antes de CADA test

    test('empieza vacío', () => expect(carrito.items, isEmpty));

    test('acumula productos', () {
      carrito.agregar('café');
      carrito.agregar('té');
      expect(carrito.items, ['café', 'té']);
    });

    tearDown(() => carrito.vaciar());       // después de cada uno
  });
}

import 'dart:async';
import 'package:test/test.dart';

Future<String> cargarDato() async {
  await Future.delayed(const Duration(milliseconds: 50));
  return 'dato';
}

void main() {
  test('cargarDato resuelve el valor esperado', () async {
    final dato = await cargarDato();
    expect(dato, 'dato');
  });

  test('un stream emite en orden', () {
    Stream<int> numeros() async* { yield 1; yield 2; }
    expect(numeros(), emitsInOrder([1, 2, emitsDone]));
  });
}

class Configuracion {
  final String tema;
  final String idioma;
  const Configuracion({this.tema = 'claro', this.idioma = 'es'});

  // Copia cambiando SOLO lo indicado:
  Configuracion copiarCon({String? tema, String? idioma}) => Configuracion(
        tema: tema ?? this.tema,
        idioma: idioma ?? this.idioma,
      );

  @override
  String toString() => '$tema/$idioma';
}

void main() {
  const base = Configuracion();
  print(base);
  print(base.copiarCon(tema: 'oscuro'));
  print(base);   // la original sigue intacta
}

// Un widget de Flutter NO ES MAGIA: es una clase final con constructor
// nombrado, campos tipados y un método que devuelve otro objeto.
class TarjetaUsuario extends StatelessWidget {
  final String nombre;
  final int edad;

  const TarjetaUsuario({super.key, required this.nombre, required this.edad});

  @override
  Widget build(BuildContext context) => Container(
        padding: const EdgeInsets.all(16),
        child: Column(
          children: [
            Text(nombre, style: const TextStyle(fontSize: 18)),
            if (edad >= 18) const Icon(Icons.verified),
          ],
        ),
      );
}

class Contador extends StatefulWidget {
  const Contador({super.key});

  @override
  State<Contador> createState() => _EstadoContador();
}

class _EstadoContador extends State<Contador> {
  int _veces = 0;

  void _incrementar() => setState(() => _veces++);   // closure sobre this

  @override
  Widget build(BuildContext context) => FilledButton(
        onPressed: _incrementar,
        child: Text('Pulsado $_veces veces'),
      );
}

// Y para datos asíncronos, FutureBuilder pinta según el estado del Future:
FutureBuilder<List<String>>(
  future: cargarUsuarios(),                 // tu función async del capítulo 31
  builder: (context, snapshot) => switch (snapshot.connectionState) {
    ConnectionState.waiting => const CircularProgressIndicator(),
    _ when snapshot.hasError => Text('Error: ${snapshot.error}'),
    _ => Text('Usuarios: ${snapshot.data?.length ?? 0}'),
  },                                        // patterns del capítulo 30
)