Diferencias entre const y static readonly en C#

En C# existen dos formas principales de definir valores constantes: const y static readonly.

A simple vista parecen similares, pero no son equivalentes. La diferencia entre ambos puede tener implicaciones importantes en rendimiento, versionado y comportamiento en tiempo de ejecución.

Cuando definimos un campo como const, su valor se conoce y se fija en tiempo de compilación.

Esto significa que el compilador reemplaza todas las referencias a esa constante por su valor literal.

public class MathUtils

{

    public const double Pi = 3.14159265359;

}

Si en otro proyecto escribimos:

Console.WriteLine(MathUtils.Pi);

El compilador incrusta el valor 3.14159265359 directamente en el código IL.

Por eso, si luego cambiamos Pi a 3.14 y recompilamos solo la librería, las aplicaciones que la usaban seguirán mostrando 3.14159265359, a menos que se recompilen también.

En resumen:

• Resuelto en tiempo de compilación.
• Solo admite tipos primitivos o string.
• Se incrusta literalmente en el código.
• No puede cambiar nunca.

Un campo static readonly se evalúa en tiempo de ejecución, no en compilación.

Su valor puede asignarse en la declaración o dentro del constructor estático de la clase.

public class Config

{

    public static readonly DateTime StartTime = DateTime.Now;

}

Aquí StartTime toma el valor actual al cargarse la clase, algo que sería imposible con const.

Otra diferencia clave: si modificamos el valor en el código fuente y recompilamos solo la librería, las aplicaciones que la referencian verán el cambio sin necesidad de recompilarse.

En resumen:

• Evaluado en tiempo de ejecución.
• Admite cualquier tipo (incluso objetos complejos).
• No se incrusta en el código cliente.
• Puede inicializarse en constructores estáticos.

Usá const cuando el valor sea verdaderamente inmutable y universal (como Math.PI, o un nombre de tabla en una base de datos).

Usá static readonly cuando el valor dependa de la ejecución o pueda cambiar sin recompilar los clientes.

Unit Testing en Elm: confianza tipada desde el compilador hasta las pruebas

Elm ya es famoso por su compilador que evita errores en tiempo de ejecución, pero eso no significa que las pruebas no sean necesarias.

De hecho, los tests en Elm complementan su sistema de tipos, ayudándote a verificar la lógica de negocio, las transformaciones de datos y el comportamiento de tus funciones puras.

A diferencia de otros lenguajes donde los tests buscan prevenir errores de nulls, tipos o efectos secundarios, en Elm los tests sirven principalmente para:

• Asegurar que una función devuelva el resultado esperado.
• Comprobar que una actualización de modelo (en TEA) cambie el estado correctamente.
• Validar transformaciones de datos o funciones puras de negocio.

Gracias a la pureza funcional, las pruebas en Elm son simples y predecibles.

El framework oficial de testing es elm-test.

Instalalo con:

npm install -g elm-test

elm-test init

Esto crea una carpeta:

tests/

 └── Example.elm

donde podrás escribir tus pruebas.

Supongamos que tenés una función en src/MathUtils.elm:

module MathUtils exposing (add)

add : Int -> Int -> Int

add a b =

    a + b

Podés crear un test en tests/MathUtilsTest.elm:

module MathUtilsTest exposing (tests)

import Expect

import Test exposing (..)

import MathUtils exposing (add)

tests : Test

tests =

    describe "Pruebas de MathUtils"

        [ test "Suma básica" <|

            \_ -> Expect.equal 4 (add 2 2)

        , test "Suma con negativos" <|

            \_ -> Expect.equal 0 (add 2 -2)

        ]

Ejecutalo con:

elm-test

y deberías ver algo como:

TEST RUN PASSED

Duration: 15 ms

Podés probar también las funciones update de tu arquitectura Elm.

Supongamos una aplicación simple que incrementa un contador:

type alias Model =

    { counter : Int }

type Msg

    = Increment

update : Msg -> Model -> Model

update msg model =

    case msg of

        Increment ->

            { model | counter = model.counter + 1 }

El test sería:

module CounterTest exposing (tests)

import Expect

import Test exposing (..)

import Main exposing (update, Model(..), Msg(..))

tests : Test

tests =

    describe "Update del contador"

        [ test "Incrementa el contador" <|

            \_ ->

                let

                    model = { counter = 0 }

                    updated = update Increment model

                in

                Expect.equal 1 updated.counter

        ]

Expect.notEqual – asegura que dos valores sean diferentes.

Expect.true / Expect.false – comprueba booleanos.

Expect.all – combina varios asserts sobre el mismo valor.

Fuzz tests – pruebas con datos aleatorios (muy útiles para funciones matemáticas o validaciones).

Ejemplo de fuzzing:

import Fuzz exposing (int)

fuzzTest : Test

fuzzTest =

    fuzz int "Suma con cero no cambia el número" <|

        \n -> Expect.equal n (add n 0)

El fuzzer genera cientos de casos aleatorios para asegurar que la propiedad siempre se cumple.

El sistema de tipos de Elm ya evita gran parte de los errores comunes, pero las pruebas unitarias llevan esa confianza un paso más allá. Te permiten documentar y verificar el comportamiento de tus funciones de forma declarativa, legible y segura.

Manejo de efectos en Elm: Tasks, Commands y Subscriptions

Elm es conocido por su promesa audaz: “sin errores en tiempo de ejecución”.

Pero, ¿cómo logra mantener esa pureza funcional incluso cuando necesita interactuar con el mundo real —hacer peticiones HTTP, leer el tiempo o escuchar eventos del navegador?

La respuesta está en su sistema de efectos controlados, manejados a través de tres conceptos clave:

• Task
• Cmd (Command)
• Sub (Subscription)

En lenguajes imperativos, un efecto secundario (como imprimir en consola, hacer un fetch, o leer el reloj) puede suceder en cualquier parte del código.

En Elm, en cambio, toda función debe ser pura: dado el mismo input, siempre devuelve el mismo output.

Esto significa que no podés ejecutar efectos directamente dentro de tus funciones —en su lugar, los describís y Elm se encarga de ejecutarlos de forma controlada.

Un Cmd (Command) representa una acción que Elm debe realizar fuera del mundo puro, y que luego generará un mensaje (msg) cuando termine.

Ejemplo: hacer una solicitud HTTP.

import Http

import Json.Decode exposing (string)

type Msg

    = GotGreeting (Result Http.Error String)

fetchGreeting : Cmd Msg

fetchGreeting =

    Http.get

        { url = "https://api.example.com/hello"

        , expect = Http.expectString GotGreeting

        }

Este Cmd Msg no ejecuta la solicitud, solo le dice al runtime de Elm:

Por favor, hacé esta petición y cuando tengas el resultado, mandame un GotGreeting.

En tu update, procesás el resultado:

update : Msg -> Model -> (Model, Cmd Msg)

update msg model =

    case msg of

        GotGreeting (Ok text) ->

            ({ model | greeting = text }, Cmd.none)

        GotGreeting (Err _) ->

            ({ model | greeting = "Error al conectar" }, Cmd.none)

Task: trabajos que pueden fallar o devolver un valor

Un Task es una descripción más general de un efecto que puede producir un resultado o un error.

Por ejemplo, si quisieras obtener el tiempo:

import Task

import Time exposing (Posix)

type Msg

    = GotTime Posix

getTime : Cmd Msg

getTime =

    Task.perform GotTime Time.now

Task.perform convierte un Task en un Cmd, para que pueda ser ejecutado por Elm.

El flujo sería:

1. Time.now devuelve un Task Never Posix (una tarea que no falla y produce un tiempo).
2. Task.perform lo transforma en un Cmd Msg.
3. Elm ejecuta el comando y manda GotTime cuando termina.

Sub msg: escuchar eventos externos

Mientras que Cmd representa acciones que Elm inicia,

Sub representa cosas que suceden fuera y Elm escucha.

Por ejemplo, escuchar el paso del tiempo:

subscriptions : Model -> Sub Msg

subscriptions model =

    Time.every 1000 Tick

Cada segundo, Elm enviará un mensaje Tick, que procesás en tu update:

type Msg

    = Tick Posix

update : Msg -> Model -> (Model, Cmd Msg)

update msg model =

    case msg of

        Tick time ->

            ({ model | currentTime = time }, Cmd.none)

Elm logra un equilibrio brillante:

• mantiene la pureza funcional del lenguaje,
• pero sin renunciar al mundo real.

Gracias a Task, Cmd y Sub, todo efecto está tipado, controlado y predecible, lo que permite que el compilador te ayude a manejar cada posible resultado.

Por eso, en Elm, incluso el caos del mundo exterior se maneja con elegancia funcional.

Cómo tener varias líneas en un switch expression en C#

Desde C# 8, el lenguaje introdujo los switch expressions, una forma más concisa y expresiva de realizar asignaciones condicionales.

Pero hay una limitación importante, cada caso solo puede contener una expresión, no un bloque de varias sentencias.

Si intentás esto:

var result = value switch

{

    1 =>

    {

        Console.WriteLine("Caso 1");

        return "Uno";

    },

    _ => "Otro"

};

El compilador se queja: > *CS1525: Invalid expression term '{'*

Esto ocurre porque una switch expression espera una sola expresión por rama, no un bloque {}.

La pregunta es cómo resolverlo: 

Opción 1: Lambda invocada inmediatamente

Si necesitás ejecutar varias líneas y devolver un resultado, podés usar una lambda expression que se ejecuta al instante:

var result = value switch

{

    1 => (() =>

    {

        Console.WriteLine("Caso 1");

        var temp = 10 * 2;

        return $"Resultado: {temp}";

    })(),

    2 => "Dos",

    _ => "Otro"

};

El truco está en (() => { ... })(): una función anónima definida y ejecutada inmediatamente.

Opción 2: Método auxiliar

Cuando el bloque es más grande o se usa varias veces, conviene delegar la lógica a un método:

var result = value switch

{

    1 => CalcularCasoUno(),

    2 => "Dos",

    _ => "Otro"

};

string CalcularCasoUno()

{

    Console.WriteLine("Caso 1");

    var temp = 10 * 2;

    return $"Resultado: {temp}";

}

Más limpio, legible y fácil de testear.

Los switch expressions son ideales para lógica declarativa y corta, pero cuando necesitás más pasos, la solución está en envolver el bloque dentro de una lambda o extraerlo a un método auxiliar.

Queue y Deque en Java

En el Java Collections Framework, las interfaces Queue<E> y Deque<E> representan estructuras de datos diseñadas para manejar elementos de forma ordenada y disciplinada, siguiendo patrones clásicos como FIFO (First-In, First-Out) o LIFO (Last-In, First-Out).

Aunque en muchos casos usamos List<E> para mantener una secuencia, las colas ofrecen operaciones especializadas que reflejan su propósito: procesar elementos en un orden determinado.

Queue<E>: la cola clásica

Una Queue (cola) sigue la política FIFO: el primer elemento en entrar es el primero en salir.

Entre los métodos principales tenemos:

• add(E e): Inserta un elemento, lanza excepción si no hay espacio. 
• offer(E e): Inserta un elemento, devuelve false si falla (no lanza excepción). 
• remove(): Elimina y devuelve el primer elemento, lanza excepción si está vacía.
• poll(): Elimina y devuelve el primer elemento, devuelve null si está vacía.
• element(): Devuelve el primer elemento sin eliminarlo, lanza excepción si está vacía.
• peek(): Devuelve el primer elemento sin eliminarlo, o null si está vacía.  

Usá offer, poll y peek cuando no quieras manejar excepciones, y add, remove, element si esperás que siempre haya elementos.

Veamos un ejemplo con LinkedList: LinkedList implementa Queue, así que se puede usar como una cola:

import java.util.*;

public class EjemploQueue {

    public static void main(String[] args) {

        Queue<String> cola = new LinkedList<>();

        cola.offer("A");

        cola.offer("B");

        cola.offer("C");

        System.out.println("Frente de la cola: " + cola.peek());

        while (!cola.isEmpty()) {

            System.out.println("Atendiendo: " + cola.poll());

        }

    }

}

Salida:

Frente de la cola: A

Atendiendo: A

Atendiendo: B

Atendiendo: C

Aquí los elementos se procesan en el mismo orden en que fueron agregados.

Implementaciones comunes de Queue:

• LinkedList: Cola basada en lista enlazada (también implementa Deque). 
• PriorityQueue: Cola que ordena sus elementos según su prioridad o un comparador.
• ArrayDeque: Implementación eficiente basada en array.
• ConcurrentLinkedQueue: Versión no bloqueante, segura para hilos.
• BlockingQueue: Interfaz extendida con operaciones que bloquean el hilo (en java.util.concurrent).

Deque<E>: doble cola

Deque (Double-Ended Queue) es una cola doble, permite insertar y eliminar elementos tanto por el frente como por el final.

Veamos un ejemplo con ArrayDeque:

import java.util.*;

public class EjemploDeque {

    public static void main(String[] args) {

        Deque<String> deque = new ArrayDeque<>();

        deque.addFirst("A");

        deque.addLast("B");

        deque.addLast("C");

        deque.addFirst("Inicio");

        System.out.println("Primero: " + deque.peekFirst());

        System.out.println("Último: " + deque.peekLast());

        while (!deque.isEmpty()) {

            System.out.println("Procesando: " + deque.pollFirst());

        }

    }

}

Salida:

Primero: Inicio

Último: C

Procesando: Inicio

Procesando: A

Procesando: B

Procesando: C

Antes de Java 1.6 se usaba la clase Stack, pero hoy se recomienda usar Deque como pila:

Deque<Integer> pila = new ArrayDeque<>();

pila.push(10); // addFirst

pila.push(20);

pila.push(30);

while (!pila.isEmpty()) {

    System.out.println("Sacando: " + pila.pop());

}

Salida:

Sacando: 30

Sacando: 20

Sacando: 10

Aquí la Deque actúa como una pila LIFO (Last-In, First-Out).

Las interfaces Queue<E> y Deque<E> amplían el poder del Java Collections Framework al modelar estructuras de datos de procesamiento secuencial, ideales para tareas como:

• Procesamiento en colas de mensajes
• Modelos productor-consumidor
• Pilas o buffers circulares
• Algoritmos de recorrido (como BFS)

La Encuesta para Desarrolladores 2025 de stackoverflow

Stackoverflow hizo su tradicional encuesta y dijo esto: 

"La Encuesta para Desarrolladores 2025 es el informe definitivo sobre el estado del desarrollo de software. En su decimoquinta edición, Stack Overflow recibió más de 49 000 respuestas de 177 países en 62 preguntas centradas en 314 tecnologías diferentes, incluyendo un nuevo enfoque en herramientas de agentes de IA, LLM y plataformas comunitarias. Esta Encuesta anual para Desarrolladores ofrece una visión general crucial de las necesidades de la comunidad global de desarrolladores, centrándose en las herramientas y tecnologías que utilizan o sobre las que desean aprender más."

Dejo link:

https://survey.stackoverflow.co/2025/

Set en Elm: conjuntos funcionales, simples y seguros

En Elm, un Set representa un conjunto de valores únicos y ordenados, sin repeticiones y con operaciones típicas de teoría de conjuntos: unión, intersección, diferencia, etc.

Un Set se define como:

Set comparable

comparable: el tipo de los valores que puede contener (por ejemplo, Int, String, Char, etc.).

Todos los valores deben ser comparables, es decir, Elm debe poder ordenarlos.

Esto significa que no podés usar listas, records o funciones dentro de un Set.

Podés crearlo vacío o a partir de una lista:

import Set exposing (Set)

-- Conjunto vacío

numeros : Set Int

numeros = Set.empty

-- Desde una lista

pares : Set Int

pares = Set.fromList [2, 4, 6, 8, 10]

Los duplicados se eliminan automáticamente:

Set.fromList [1, 2, 2, 3]

-- Resultado: {1, 2, 3}

Set.member 4 pares

-- True

Set.member 5 pares

-- False

-- Agregar un elemento

paresActualizados =

    Set.insert 12 pares

-- Eliminar un elemento

paresFiltrados =

    Set.remove 8 paresActualizados

Recordá: todo es inmutable. Cada operación devuelve un nuevo Set, sin modificar el original.

Podés convertir un Set a lista:

Set.toList pares

-- [2,4,6,8,10]

Y viceversa:

Set.fromList [3,1,2]

-- {1,2,3}

Para aplicar transformaciones, primero lo convertís a lista y luego de vuelta:

paresDoblados =

    Set.fromList (List.map (\x -> x * 2) (Set.toList pares))

Elm ofrece las funciones clásicas de teoría de conjuntos:

Set.union: Unión de dos conjuntos

Set.union (Set.fromList [1,2]) (Set.fromList [2,3])  --> {1,2,3}

Set.intersect: Intersección 

Set.intersect (Set.fromList [1,2,3]) (Set.fromList [2,3,4])  --> {2,3}

Set.diff: Diferencia

Set.diff (Set.fromList [1,2,3]) (Set.fromList [2])  --> {1,3}

Set.isEmpty:¿Está vacío?

Set.isEmpty Set.empty --> True

Set.size: Cantidad de elementos

Set.size (Set.fromList [1,2,3]) --> 3

Gracias al sistema de tipos de Elm:

• No hay null ni valores inesperados.
• No podés mezclar tipos diferentes dentro del mismo Set.
• Todas las operaciones son puras e inmutables.

Por ejemplo:

-- Esto da error de compilación

Set.fromList [1, "dos", 3]

Hablemos de ArrayList

La clase ArrayList en Java es una de las colecciones más utilizadas del paquete java.util.

Está implementada internamente sobre un arreglo dinámico, y su código fuente se encuentra en java.util.ArrayList dentro del JDK.

Veamos cómo funciona en detalle:

Internamente, ArrayList mantiene un array (arreglo) de tipo Object[] llamado elementData donde guarda los elementos:

public class ArrayList<E> extends AbstractList<E>

        implements List<E>, RandomAccess, Cloneable, java.io.Serializable {

    private static final int DEFAULT_CAPACITY = 10;

    private static final Object[] EMPTY_ELEMENTDATA = {};

    private transient Object[] elementData;

    private int size;

}

• elementData: el arreglo donde se almacenan los elementos.
• size: la cantidad actual de elementos.
• DEFAULT_CAPACITY: capacidad inicial (10).
• EMPTY_ELEMENTDATA: usado cuando el ArrayList está vacío.

Cuando creás un ArrayList sin indicar capacidad:

List<String> list = new ArrayList<>();

internamente no se reserva espacio aún. Se crea con elementData = EMPTY_ELEMENTDATA.

Recién al agregar el primer elemento, se inicializa con una capacidad por defecto (10).

Cuando llamás a:

list.add("Hola");

Java hace esto internamente:

public boolean add(E e) {

    ensureCapacityInternal(size + 1);

    elementData[size++] = e;

    return true;

}

Y ensureCapacityInternal verifica si el arreglo tiene espacio suficiente:

private void ensureCapacityInternal(int minCapacity) {

    if (elementData == EMPTY_ELEMENTDATA) {

        minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);

    }

    ensureExplicitCapacity(minCapacity);

}

Si no hay espacio, llama a grow():

private void grow(int minCapacity) {

    int oldCapacity = elementData.length;

    int newCapacity = oldCapacity + (oldCapacity >> 1); // 1.5 veces más

    if (newCapacity - minCapacity < 0)

        newCapacity = minCapacity;

    elementData = Arrays.copyOf(elementData, newCapacity);

}

Cuando se queda sin espacio, duplica la capacidad en un 50% (crecimiento amortizado).

Acceder es O(1) porque es un arreglo:

public E get(int index) {

    rangeCheck(index);

    return (E) elementData[index];

}

Cuando quitás un elemento:

list.remove(2);

se mueve el resto de los elementos para no dejar “huecos”:

public E remove(int index) {

    rangeCheck(index);

    E oldValue = elementData(index);

    int numMoved = size - index - 1;

    if (numMoved > 0)

        System.arraycopy(elementData, index + 1, elementData, index, numMoved);

    elementData[--size] = null; // libera la referencia

    return oldValue;

}

Esto hace que remove sea O(n) en el peor caso (por el corrimiento de elementos).

Veamos ventajas y desventajas

Ventajas:

• Acceso aleatorio rápido (O(1)).
• Memoria contigua, lo que mejora la localidad de referencia.
• Crece automáticamente.

Desventajas:

• Insertar o eliminar en el medio es costoso (O(n)).
• Aumentar la capacidad implica copiar el arreglo completo.

ArrayList es básicamente una versión moderna y no sincronizada de Vector.

Si necesitás sincronización, podés envolverlo así:

List<String> syncList = Collections.synchronizedList(new ArrayList<>());

Array en Elm: eficiencia y acceso rápido a los datos

En Elm, las listas (List) son muy comunes, pero cuando necesitamos acceso rápido por índice, actualizaciones eficientes o manejar colecciones grandes, entra en juego Array.

Un Array en Elm es una estructura inmutable y eficiente que permite:

• Acceder a elementos por índice (O(log n)).
• Actualizar posiciones específicas sin mutar el original.
• Convertirse fácilmente a listas (`List`) y viceversa.

Su módulo se importa así:

import Array exposing (Array)

Podés crearlo vacío o a partir de una lista:

-- Array vacío

vacio : Array Int

vacio = Array.empty

-- Desde una lista

numeros : Array Int

numeros = Array.fromList [10, 20, 30, 40]

Y también convertirlo nuevamente a lista:

Array.toList numeros

-- [10, 20, 30, 40]

Para obtener el valor en un índice determinado:

Array.get 2 numeros

-- Just 30

Observá que devuelve un Maybe, ya que el índice podría no existir.

Array.get 10 numeros

-- Nothing

-- Actualizar el valor en la posición 1

actualizado =

    Array.set 1 25 numeros

Array.toList actualizado

-- [10, 25, 30, 40]

Cada modificación devuelve un nuevo Array, sin alterar el original (inmutabilidad funcional).

Para agregar al final, usamos Array.push:

conNuevo =

    Array.push 50 numeros

Array.toList conNuevo

-- [10, 20, 30, 40, 50]

Y para quitar el último, usamos Array.pop:

sinUltimo =

    Array.pop conNuevo

Array.toList sinUltimo

-- [10, 20, 30, 40]

Podés recorrerlo de manera muy parecida a una lista:

Array.map (\x -> x * 2) numeros

-- {20, 40, 60, 80}

Y también filtrarlo o transformarlo:

Array.filter (\x -> x > 20) numeros

-- {30, 40}

Y hay más!! :

Array.length: Devuelve el tamaño          

Array.length numeros --> 4

                       |

Array.isEmpty: ¿Está vacío? 

Array.isEmpty Array.empty --> True

Array.initialize: Crea un array con una función

Array.initialize 5 (\i -> i * 2) --> {0,2,4,6,8}

Array.foldl/Array.foldr: Reduce el array

Array.foldl (+) 0 numeros --> 100                |

Veamos un ejemplo completo:

import Array exposing (Array)

main =

    let

        nums = Array.fromList [1,2,3,4]

        dobles = Array.map (\n -> n * 2) nums

        filtrados = Array.filter (\n -> n > 4) dobles

    in

    Array.toList filtrados

    

-- Resultado: [6,8]

Array en Elm te da:

• Acceso rápido por índice
• Inmutabilidad garantizada
• Operaciones eficientes
• Interoperabilidad con List

Usá List cuando pienses en secuencias y Array cuando necesites posiciones.

Dict en Elm: Diccionarios funcionales para datos ordenados

En Elm, un Dict (abreviatura de Dictionary) es una estructura de datos inmutable que almacena pares clave–valor, de forma ordenada y segura por tipos.

Un Dict se define como:

Dict comparable value

• comparable → tipo de la clave (por ejemplo, `String`, `Int`, etc.)
• value → tipo del valor asociado

Solo podés usar tipos comparables como claves, es decir, tipos con un orden definido (Int, String, Char, etc.).

No podés usar listas, records o funciones como claves.

Podés crear un diccionario vacío o con elementos iniciales:

import Dict exposing (Dict)

-- Vacío

usuarios : Dict Int String

usuarios = Dict.empty

-- Con valores

usuariosIniciales : Dict Int String

usuariosIniciales =

    Dict.fromList

        [ (1, "Ana")

        , (2, "Luis")

        , (3, "María")

        ]

Para buscar un valor por su clave:

Dict.get 2 usuariosIniciales

-- Resultado: Just "Luis"

Dict.get 5 usuariosIniciales

-- Resultado: Nothing

El resultado es un Maybe, lo que evita errores por claves inexistentes.

Podés manejarlo así:

case Dict.get 5 usuariosIniciales of

    Just nombre ->

        "Usuario encontrado: " ++ nombre

    Nothing ->

        "No existe ese usuario."

Insertar y eliminar elementos:

-- Agregar o actualizar

usuarios2 =

    Dict.insert 4 "Sofía" usuariosIniciales

-- Eliminar

usuarios3 =

    Dict.remove 2 usuarios2

Todo es inmutable: estas operaciones devuelven un nuevo Dict, no modifican el original.

Podés convertirlo a lista y trabajar con sus elementos:

Dict.toList usuariosIniciales

-- [(1, "Ana"), (2, "Luis"), (3, "María")]

List.map (\(id, nombre) -> nombre ++ " (" ++ String.fromInt id ++ ")")

    (Dict.toList usuariosIniciales)

O usar funciones específicas:

Dict.map (\_ nombre -> String.toUpper nombre) usuariosIniciales

Dict.member key dict: ¿Existe la clave?                   

Dict.size dict: Cantidad de elementos               

Dict.keys dict: Lista de claves                     

Dict.values dict: Lista de valores                    

Dict.filter pred dict: Filtra según condición              

Dict.union d1 d2: Une dos diccionarios                

Dict.merge: Mezcla con control sobre conflictos 

Dict en Elm es:

• Inmutable
• Ordenado por clave
• Seguro (usa `Maybe` para búsquedas)
• Funcional y expresivo

En Elm, un Dict es más que un mapa: es una garantía de orden, seguridad y pureza funcional.

La STL en C++: tu mejor aliada del día a día

La STL (Standard Template Library) es uno de los pilares más poderosos de C++.

Nos brinda estructuras de datos genéricas, algoritmos reutilizables y utilidades funcionales para escribir código más limpio, rápido y seguro.

Vamos a repasar sus componentes principales y las funciones más usadas.

La STL nos da varios tipos de contenedores, cada uno con su propósito:

• vector: Lista dinámica, similar a un array redimensionable 
• std::vector<int> v = {1,2,3};       
• list: Lista doblemente enlazada  
• std::list<std::string> nombres;
• deque: Doble cola (insertar por ambos extremos) 
• std::deque<int> d;
• set: Conjunto ordenado, sin duplicados
• std::set<int> numeros;
• map: Diccionario (clave → valor) ordenado 
• std::map<std::string, int> edades;
• unordered_map: Diccionario sin orden, pero más rápido
• std::unordered_map<int, std::string> alumnos;

Los algoritmos de la STL trabajan sobre iteradores, lo que los hace genéricos y potentes.

#include <algorithm>

#include <vector>

#include <iostream>

int main() {

    std::vector<int> numeros = {3, 1, 4, 1, 5, 9};

    // sort: ordena

    std::sort(numeros.begin(), numeros.end());

    // reverse: invierte

    std::reverse(numeros.begin(), numeros.end());

    // count: cuenta ocurrencias

    int cantidad = std::count(numeros.begin(), numeros.end(), 1);

    // find: busca un elemento

    auto it = std::find(numeros.begin(), numeros.end(), 5);

    if (it != numeros.end())

        std::cout << "Encontrado: " << *it << std::endl;

    // accumulate: suma o acumula valores

    int suma = std::accumulate(numeros.begin(), numeros.end(), 0);

    std::cout << "Suma total: " << suma << std::endl;

}

Estos algoritmos no dependen del tipo de contenedor.

Si el contenedor tiene iteradores, funciona igual.

Veamos funciones:

std::copy_if: Copia elementos que cumplan una condición 

copy_if(v.begin(), v.end(), back_inserter(res), [](int n){ return n > 3; });

std::transform: Aplica una función a cada elemento

transform(v.begin(), v.end(), v.begin(), [](int n){ return n * 2; });

std::for_each: Itera con una función lambda

for_each(v.begin(), v.end(), [](int n){ cout << n << " "; });                     

std::remove_if: Elimina (lógicamente) los elementos que cumplan una condición

v.erase(remove_if(v.begin(), v.end(), [](int n){ return n % 2 == 0; }), v.end());

Veamos funciones matematicas comunes:

std::min_element(v.begin(), v.end());

std::max_element(v.begin(), v.end());

std::accumulate(v.begin(), v.end(), 0);

std::inner_product(v.begin(), v.end(), v2.begin(), 0);

Y por ultimo unos trucos:

• Usá auto para no repetir tipos largos.
• Preferí algoritmos STL + lambdas antes que bucles manuales.
• Aprovechá std::optional, std::variant y std::tuple (desde C++17) para código más expresivo.

La STL no es solo una librería: es una forma de pensar en C++.

En lugar de escribir bucles y estructuras manuales, usás herramientas ya optimizadas, seguras y expresivas.

Mónadas en Elm: Encadenando Cálculos con Elegancia

Las mónadas son un concepto central en la programación funcional. Aunque suenen complicadas, en Elm ya las usamos todo el tiempo sin darnos cuenta.

En términos simples: Una mónada es un funtor con una forma de encadenar operaciones que devuelven estructuras.

En Elm esto se hace con funciones como andThen (también llamada bind en otros lenguajes).

Maybe como mónada: Cuando trabajamos con valores opcionales (Maybe), podemos encadenar operaciones sin preocuparnos por el caso Nothing.

dividir : Int -> Int -> Maybe Int

dividir a b =

    if b == 0 then

        Nothing

    else

        Just (a // b)

calculo : Maybe Int

calculo =

    Just 100

        |> Maybe.andThen (\x -> dividir x 2)

        |> Maybe.andThen (\y -> dividir y 5)

-- Resultado: Just 10

Si en algún paso se produce un Nothing, toda la cadena devuelve Nothing automáticamente.

Result como mónada

Con Result, podemos propagar errores sin necesidad de escribir mucho código repetitivo:

parseEntero : String -> Result String Int

parseEntero s =

    case String.toInt s of

        Just n -> Ok n

        Nothing -> Err "No es un número"

invertir : Int -> Result String Float

invertir n =

    if n == 0 then

        Err "División por cero"

    else

        Ok (1 / toFloat n)

calculo : Result String Float

calculo =

    parseEntero "10"

        |> Result.andThen invertir

-- Resultado: Ok 0.1

Si el parseo falla, se corta la cadena con Err. Si no, se sigue con el siguiente cálculo.

List como mónada

Con listas, una mónada nos permite generar todas las combinaciones posibles de elementos:

pares : List (Int, Int)

pares =

    [1, 2]

        |> List.concatMap (\x ->

            [3, 4] |> List.map (\y -> (x, y))

        )

-- Resultado: [(1,3),(1,4),(2,3),(2,4)]

Esto es equivalente a las list comprehensions en Haskell.

Resumen de funciones clave en Elm

• Maybe.andThen → encadena operaciones opcionales.
• Result.andThen → encadena operaciones que pueden fallar con error.
• List.concatMap → encadena operaciones que generan más listas.

Todas siguen el mismo patrón monádico.

En Elm, aunque no hablemos directamente de “Mónadas” en la sintaxis, las usamos constantemente.

fold en Elm: Reducción de Listas Paso a Paso

En programación funcional, fold (también conocido como reducción) es una técnica para recorrer una lista y acumular un resultado.

En Elm tenemos dos variantes principales:

List.foldl → recorre la lista de izquierda a derecha.

List.foldr → recorre la lista de derecha a izquierda.

Ambos reciben:

1. Una función acumuladora.
2. Un valor inicial.
3. La lista a recorrer.

Y devuelven un único valor.

Veamos un ejemplo:

suma : List Int -> Int

suma lista =

    List.foldl (\x acc -> x + acc) 0 lista

-- suma [1,2,3,4] == 10

Aquí:

• (\x acc -> x + acc) es la función acumuladora.
• 0 es el valor inicial.
• lista es la lista que recorremos.

Otro ejemplo:

concatenar : List String -> String

concatenar palabras =

    List.foldl (\palabra acc -> palabra ++ " " ++ acc) "" palabras

-- concatenar ["Hola", "mundo"] == "Hola mundo "

Ojo: el orden importa. Si usás `foldr`, el resultado cambia:

List.foldr (\palabra acc -> palabra ++ " " ++ acc) "" ["Hola", "mundo"]

-- "Hola mundo "

En este caso no hay diferencia visible, pero con listas grandes o con operaciones no conmutativas sí la hay.

Otro ejemplo: Calcular el producto (foldl vs foldr)

producto : List Int -> Int

producto =

    List.foldl (\x acc -> x * acc) 1

-- producto [1,2,3,4] == 24

Con foldr se obtiene el mismo resultado porque la multiplicación es conmutativa.

Veamos el orden de evaluación:

foldl (izquierda a derecha):

  foldl f acc [1,2,3]

  == f 3 (f 2 (f 1 acc))

foldr (derecha a izquierda):

  foldr f acc [1,2,3]

  == f 1 (f 2 (f 3 acc))

Esto puede cambiar el resultado cuando la operación no es conmutativa, o puede impactar en la performance con listas grandes.

Veamos otro ejemplo: 

invertir : List a -> List a

invertir lista =

    List.foldl (\x acc -> x :: acc) [] lista

-- invertir [1,2,3] == [3,2,1]

En Elm, fold es una herramienta poderosa para:

• Reducir listas a un único valor.
• Evitar bucles explícitos.
• Expresar cálculos de manera declarativa.

Usá foldl cuando quieras acumular de izquierda a derecha (más común y eficiente).

Usá foldr cuando necesites preservar el orden de construcción en estructuras recursivas.

Ignorar vs. Descartar Valores de Retorno en C#

En C# es común encontrarnos con métodos que devuelven un valor que a veces no necesitamos. En esos casos, hay dos formas de manejarlo: ignorar o descartar explícitamente. Aunque parecen lo mismo, hay una diferencia sutil pero importante.

1. Ignorar el valor

File.Exists("config.json");

Aquí llamamos al método, pero el valor (true o false) se ignora directamente.

El compilador lo interpreta como si el resultado no fuera relevante.

2. Descartar explícitamente con _ =

_ = File.Exists("config.json");

En este caso, el valor de retorno se asigna al identificador especial _, conocido como discard. Esto indica explícitamente que sabemos que existe un valor, pero decidimos no usarlo.

• Si el método devuelve void, ambas formas son equivalentes.
• Si el método devuelve un valor, la diferencia es semántica:
• File.Exists(...); → Ignorás el valor.
• _ = File.Exists(...); → Descartás el valor de manera explícita.

Esto es útil con reglas de análisis estático, como CA1806 (Do not ignore method results), que pueden marcar advertencias si el resultado se ignora, pero no si se descarta explícitamente.

Veamos un ejemplo completo:

bool success = int.TryParse("123", out int number);

// Opción 1: ignorar el retorno

int.TryParse("456", out int _);   // algunos analizadores generan warning

// Opción 2: descartar explícitamente el retorno

_ = int.TryParse("789", out int _); // sin warning, el descarte es intencional

• Usar _ = no cambia el comportamiento del programa.
• Sirve para comunicar intencionalidad al compilador y a otros desarrolladores.
• Si querés ser más explícito (y evitar advertencias de análisis), preferí la forma con _ =.

Functores en Elm

En programación funcional, un funtor es una estructura de datos que sabe cómo aplicar una función a los valores que contiene, sin que tengamos que preocuparnos por los detalles internos.

En Elm, el concepto de funtor aparece principalmente con el uso de map en distintos tipos.

 ¿Qué es un funtor?

En términos simples:

Un funtor es algo sobre lo que podemos hacer map.

Nos permite aplicar una función a un valor dentro de un contexto (List, Maybe, Result, etc.).

Veamos unos ejemplos: 

Maybe como List:

dobles : List Int

dobles =

    List.map (\x -> x * 2) [1, 2, 3]

-- Resultado: [2, 4, 6]

Acá List es un funtor, porque podemos aplicar una función a todos sus elementos usando map.

Maybe como funtor:

incrementar : Maybe Int -> Maybe Int

incrementar valor =

    Maybe.map (\x -> x + 1) valor

-- incrementar (Just 5) == Just 6

-- incrementar Nothing == Nothing

El map de Maybe aplica la función solo si hay un valor (Just), y deja todo igual si es Nothing.

Result como funtor

toUppercase : Result String String -> Result String String

toUppercase resultado =

    Result.map String.toUpper resultado

-- toUppercase (Ok "elm") == Ok "ELM"

-- toUppercase (Err "Error") == Err "Error"

El map de Result aplica la función al valor exitoso (Ok), y en caso de error (Err) no hace nada.

Todo funtor debe cumplir dos leyes:

1. Identidad:

   List.map identity xs == xs

   Aplicar la función identity no debe cambiar nada.

2. Composición:

   List.map (f >> g) xs == (List.map f >> List.map g) xs

   Aplicar dos funciones compuestas debe ser lo mismo que aplicarlas de a una.

En Elm, los funtores nos permiten:

• Aplicar funciones de forma elegante a valores dentro de contextos.
• Evitar escribir lógica repetida para casos como Nothing o Err.
• Pensar en términos más declarativos y expresivos.

Siempre que uses map en List, Maybe o Result, ¡estás usando funtores en Elm!