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!