Ejemplo 1: ignorar el primer valor con O.andThen

Concepto

La función O.andThen le permite ejecutar una secuencia de dos Opciones, donde el resultado está determinado únicamente por la segunda Opción. Esto es útil cuando la primera opción tiene un propósito, pero su valor no es necesario en operaciones posteriores.

Código

function sequencing_ex01() {
  const some1 = O.some(1); // Create an Option containing the value 1
  const some2 = O.some(2); // Create an Option containing the value 2
  const none = O.none(); // Create an Option representing no value

  console.log(pipe(some1, O.andThen(some2))); // Output: Some(2) (ignores 1 and returns 2)
  console.log(pipe(none, O.andThen(some2))); // Output: None (since the first Option is None)
}

Explicación

• pipe(some1, O.andThen(some2)): Aquí, some1 contiene el valor 1, pero la operación lo ignora y devuelve some2, que contiene 2.
• pipe(none, O.andThen(some2)): Dado que la primera opción es Ninguna, la operación produce un cortocircuito y devuelve Ninguna.

Esta operación de secuenciación es particularmente útil cuando desea encadenar operaciones pero solo está interesado en el resultado de la segunda operación.

Ejemplo 2: aplanar opciones anidadas con O.flatten

Concepto

La función O.flatten está diseñada para manejar opciones anidadas eliminando un nivel de anidación. Esto es útil cuando sus operaciones dan como resultado una Opción de Opción y necesita simplificarla en una sola Opción.

Código

function sequencing_ex02() {
  const nestedSome = O.some(O.some(1)); // Create a nested Option containing the value 1
  const nestedNone = O.some(O.none()); // Create a nested Option representing no value
  const none = O.none(); // Create an Option representing no value

  console.log(pipe(nestedSome, O.flatten)); // Output: Some(1) (flattens the nested Option)
  console.log(pipe(nestedNone, O.flatten)); // Output: None (flattens to None)
  console.log(pipe(none, O.flatten)); // Output: None (since the outer Option is None)
}

Explicación

• pipe(nestedSome, O.flatten): Esto aplana la opción de opción en una sola opción, lo que da como resultado Some(1).
• pipe(nestedNone, O.flatten): La opción interna es Ninguna, por lo que al aplanarla se obtiene Ninguna.
• pipe(none, O.flatten): Si la opción externa es Ninguna, el aplanamiento no tiene ningún efecto y se devuelve Ninguno.

El aplanamiento es esencial cuando se trata de funciones que pueden devolver opciones anidadas, lo que le permite simplificar el resultado en un único valor de opción.

Ejemplo 3: composición de funciones que devuelven opciones con O.composeK

Concepto

La función O.composeK le permite componer dos funciones que devuelven una opción, creando una canalización donde la salida de la primera función se introduce en la segunda. Esto es particularmente útil para encadenar operaciones que pueden fallar y dar como resultado Ninguno.

Código

function sequencing_ex03() {
  const parseNumber = (s: string): O.Option => {
    const n = parseInt(s, 10);
    return isNaN(n) ? O.none() : O.some(n);
  };

  const doubleIfPositive = (n: number): O.Option =>
    n > 0 ? O.some(n * 2) : O.none();

  const parseAndDouble = pipe(parseNumber, O.composeK(doubleIfPositive));

  console.log(parseAndDouble('42')); // Output: Some(84) (parses and doubles the number)
  console.log(parseAndDouble('-1')); // Output: None (since -1 is not positive)
  console.log(parseAndDouble('abc')); // Output: None (since 'abc' is not a number)
}

Explicación

• parseAndDouble('42'): La cadena '42' se analiza correctamente en un número y, como es positiva, se duplica, lo que da como resultado Some(84).
• parseAndDouble('-1'): La cadena '-1' se analiza, pero como es negativa, la función devuelve Ninguno.
• parseAndDouble('abc'): La cadena 'abc' no se puede analizar como un número, por lo que la función devuelve Ninguno.

Componer funciones de retorno de opciones le permite crear cadenas complejas de operaciones mientras maneja de forma segura casos en los que cualquier paso de la cadena puede fallar.

Conclusión

Estos ejemplos muestran la versatilidad y el poder del tipo Opción en Effect-TS para manejar secuencias de operaciones. Ya sea que esté ignorando valores con O.andThen, aplanando opciones anidadas con O.flatten o componiendo operaciones con O.composeK, estos patrones le permiten administrar valores opcionales de manera más efectiva en un contexto de programación funcional. Al aprovechar estas técnicas, puede escribir código más sólido y conciso, asegurando que las operaciones manejen con elegancia la ausencia de valores mientras mantienen una lógica clara y legible.