Effect-TS proporciona herramientas poderosas para manejar los tipos Opción y Cualquiera. En este artículo, exploraremos varias formas de convertir y manipular estos tipos utilizando las funciones de utilidad de la biblioteca.

Ejemplo 1: convertir cualquiera en una opción con O.getRight

La función O.getRight convierte una opción en una opción, descartando el error. Si cualquiera de los dos es correcto, devuelve O.some(valor); de lo contrario, devuelve O.none.

import { Option as O, Either as E, pipe } from 'effect';

function conversions_ex01() {
  const eitherRight = E.right('ok'); // Create an Either containing the value 'ok'
  const eitherLeft = E.left('error'); // Create an Either representing an error

  console.log(O.getRight(eitherRight)); // Output: Some('ok')
  console.log(O.getRight(eitherLeft)); // Output: None
}

Ejemplo 2: convertir cualquiera en una opción con O.getLeft

La función O.getLeft convierte una opción en una opción, descartando el valor. Si queda Ninguno, devuelve O.some(error); de lo contrario, devuelve O.none.

import { Option as O, Either as E, pipe } from 'effect';

function conversions_ex02() {
  const eitherRight = E.right('ok'); // Create an Either containing the value 'ok'
  const eitherLeft = E.left('error'); // Create an Either representing an error

  console.log(O.getLeft(eitherRight)); // Output: None
  console.log(O.getLeft(eitherLeft)); // Output: Some('error')
}

Ejemplo 3: Obtener valor o valor predeterminado con O.getOrElse

La función O.getOrElse devuelve el valor dentro de la Opción si es Some; de ​​lo contrario, devuelve el valor predeterminado proporcionado.

import { Option as O, pipe } from 'effect';

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

  console.log(
    pipe(
      some,
      O.getOrElse(() => 'default')
    )
  ); // Output: 1 (since some contains 1)
  console.log(
    pipe(
      none,
      O.getOrElse(() => 'default')
    )
  ); // Output: 'default' (since none is None)
}

Ejemplo 4: encadenamiento de opciones con O.orElse

La función O.orElse devuelve la opción proporcionada que, si self es Ninguno, de lo contrario devuelve self. Esta función permite encadenar Opciones donde el respaldo es otra Opción.

import { Option as O, pipe } from 'effect';

function conversions_ex04() {
  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.orElse(() => some2)
    )
  ); // Output: Some(1) (since some1 contains 1)
  console.log(
    pipe(
      none,
      O.orElse(() => some2)
    )
  ); // Output: Some(2) (since none is None and fallback is some2)
}

Ejemplo 5: recurrir a un valor predeterminado con O.orElseSome

La función O.orElseSome devuelve el valor predeterminado proporcionado incluido en Some si self es Ninguno; de lo contrario, devuelve self. Esta función permite encadenar opciones donde el respaldo es un valor predeterminado incluido en Some.

import { Option as O, pipe } from 'effect';

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

  console.log(
    pipe(
      some,
      O.orElseSome(() => 2)
    )
  ); // Output: Some(1) (since some contains 1)
  console.log(
    pipe(
      none,
      O.orElseSome(() => 2)
    )
  ); // Output: Some(2) (since none is None and fallback is 2)
}

Ejemplo 6: Encadenamiento de opciones con cualquier contexto usando O.orElseEither

La función O.orElseEither devuelve una opción que contiene una opción, donde Izquierda es de la opción alternativa y Derecha es de la opción original. Esta función permite encadenar opciones donde el respaldo proporciona una cualquiera para obtener más contexto.

import { Option as O, Either as E, pipe } from 'effect';

function conversions_ex06() {
  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.orElseEither(() => some2)
    )
  ); // Output: Some(Right(1)) (since some1 contains 1)
  console.log(
    pipe(
      none,
      O.orElseEither(() => some2)
    )
  ); // Output: Some(Left(2)) (since none is None and fallback is some2)
}

Ejemplo 7: encontrar el primer algunos en un iterable con O.firstSomeOf

La función O.firstSomeOf devuelve el primer Some encontrado en un iterable de Opciones. Si todos son Ninguno, devuelve Ninguno.

import { Option as O } from 'effect';

function conversions_ex07() {
  const options = [O.none(), O.some(1), O.some(2)]; // Create an iterable of Options
  const optionsAllNone = [O.none(), O.none()]; // Create an iterable of None Options

  console.log(O.firstSomeOf(options)); // Output: Some(1) (since the first non-None Option is Some(1))
  console.log(O.firstSomeOf(optionsAllNone)); // Output: None (since all Options are None)
}

Ejemplo 8: Convertir una función que devuelve una opción a Type Guard con O.toRefinement

La función O.toRefinement convierte una función que devuelve una opción en una protección de tipo, lo que permite una verificación de tipo más específica.

import { Option as O } from 'effect';

function conversions_ex08() {
  const isPositive = (n: number): O.Option => n > 0 ? O.some(n) : O.none();
  const isPositiveRefinement = O.toRefinement(isPositive);

  console.log(isPositiveRefinement(1)); // Output: true (since 1 is positive)
  console.log(isPositiveRefinement(-1)); // Output: false (since -1 is not positive)
}

Ejemplo 9: convertir una opción en una matriz con O.toArray

La función O.toArray convierte una opción en una matriz. Si la opción es Alguna, devuelve una matriz que contiene el valor; si es Ninguno, devuelve una matriz vacía.

import { Option as O } from 'effect';

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

  console.log(O.toArray(some)); // Output: [1] (since some contains 1)
  console.log(O.toArray(none)); // Output: [] (since none is None)
}

Conclusión

En este artículo, hemos explorado varias funciones proporcionadas por Effect-TS para convertir y manipular los tipos Opción y Cualquiera. Estas funciones mejoran la flexibilidad y expresividad de su código, permitiéndole manejar valores opcionales y propensos a errores con mayor elegancia. Ya sea que necesite convertir una opción en una opción, encadenar múltiples valores de opción o realizar operaciones con seguridad de tipos, Effect-TS ofrece un sólido conjunto de herramientas para simplificar estas tareas. Al aprovechar estas utilidades, puede escribir código más limpio y fácil de mantener que maneje de manera efectiva la presencia o ausencia de valores.