DEV Community: Alessandro Maclaine

Either Algebraic Data Type

Alessandro Maclaine — Wed, 09 Oct 2024 18:13:52 +0000

The Either type is a fundamental data structure commonly used in functional programming for error handling and decision-making. It represents a value that can either be a success (Right) or a failure (Left). This is particularly useful for handling operations that might fail, allowing you to easily represent both outcomes.

This guide provides an overview of the Either type, the key functions associated with it, and how to use it in various scenarios.

Motivation and Role of `Either` in Functional Programming

In functional programming, error handling can be challenging because functions are typically pure, meaning they do not have side effects like throwing exceptions. The Either type provides a way to handle errors without breaking purity, allowing functions to return either a successful value (Right) or an error (Left).

Key Benefits of `Either`

Explicit Error Handling: Unlike throwing exceptions, Either makes error handling explicit. This forces developers to handle both success and failure cases, reducing the likelihood of unhandled errors. This is in contrast to exception-based error handling in Object-Oriented Programming (OOP) languages, where exceptions can be thrown from anywhere, making it harder to track and handle errors consistently.
Composability: Functional programming emphasizes composing functions. Either fits well into this model, allowing multiple computations to be chained together in a safe manner using functions like flatMap. This is similar to how monads are used in Haskell to handle computations that may fail, providing a consistent and composable way to manage errors.
Improved Readability: By representing success and failure in a single type, Either makes the control flow of programs clearer and more readable, especially when compared to traditional error handling mechanisms like return codes or exceptions.

Comparison with Other Error Handling Methods

Return Codes (C)

In languages like C, error handling is often done using return codes. Functions return an integer value to indicate success or failure, and the caller must check this value to determine if an error occurred. This approach is error-prone, as it relies on the programmer to remember to check the return value every time. It also lacks type safety, making it easy to accidentally ignore errors or misinterpret return values.

Example - Return Codes in C

#include <stdio.h>

int divide(int numerator, int denominator, int* result) {
  if (denominator == 0) {
    return -1; // Error code for division by zero
  }
  *result = numerator / denominator;
  return 0; // Success code
}

int main() {
  int result;
  int status = divide(10, 2, &result);
  if (status == 0) {
    printf("Result: %d\n", result);
  } else {
    printf("Error: Division by zero\n");
  }
  return 0;
}

In this example, the caller must remember to check the return status of the divide function. Forgetting to do so can lead to undefined behavior, making the code less reliable and harder to maintain.

Exceptions (OOP Languages)

In many Object-Oriented Programming (OOP) languages like Java or C#, exceptions are used to handle errors. Exceptions allow for separating normal control flow from error handling, but they come with their own set of problems. Exceptions can be thrown from deep within the call stack, making it difficult to understand where an error originated and how to handle it appropriately. This can lead to unexpected behavior if exceptions are not caught properly. Additionally, exceptions break the flow of pure functions, making reasoning about the code harder.

Example - Exceptions in Java

public class Division {
  public static void main(String[] args) {
    try {
      int result = divide(10, 0);
      System.out.println("Result: " + result);
    } catch (ArithmeticException e) {
      System.out.println("Error: " + e.getMessage());
    }
  }

  public static int divide(int numerator, int denominator) {
    if (denominator == 0) {
      throw new ArithmeticException("Division by zero");
    }
    return numerator / denominator;
  }
}

In this example, an exception is thrown when attempting to divide by zero. The try-catch block is used to handle the exception, but if the exception is not properly caught, it can lead to program crashes or unpredictable behavior. This makes the control flow harder to follow and increases the risk of unhandled errors.

`Either` in Functional Programming

The Either type addresses the shortcomings of return codes and exceptions by making error handling explicit and composable. Unlike return codes, Either provides type safety, ensuring that errors cannot be ignored. Unlike exceptions, Either does not break the flow of the program and keeps all possible outcomes visible at the type level, making the code easier to reason about and maintain.

Example - Using `Either` in TypeScript

import { Either } from "effect"

const divide = (numerator: number, denominator: number): Either<number, string> => {
  return denominator === 0 ? Either.left("Division by zero error") : Either.right(numerator / denominator)
}

const result = divide(10, 2)
const errorResult = divide(10, 0)

console.log(result) // Either.right(5)
console.log(errorResult) // Either.left("Division by zero error")

In this example, the divide function explicitly returns an Either, which can be a Right containing the result or a Left containing an error message. This ensures that the caller must handle both cases, making the error handling explicit and the flow of the program more predictable.

With Either, error handling becomes enforced by the type system itself. The compiler will ensure that both Right and Left cases are addressed wherever the Either value is used. This leads to logical consistency and correctness, as developers cannot inadvertently ignore error scenarios. By having both success and failure paths represented as part of the type, Either ensures that functions consuming the result must explicitly account for both outcomes, leading to safer, more reliable code.

Rust and Haskell

In Rust, the Result type serves a similar purpose to Either. It is used for error handling and explicitly represents either a success (Ok) or an error (Err). This approach forces the programmer to handle both cases, similar to Either, and avoids the pitfalls of unchecked exceptions.

Example - Using `Result` in Rust

fn divide(numerator: i32, denominator: i32) -> Result<i32, String> {
    if denominator == 0 {
        Err(String::from("Division by zero error"))
    } else {
        Ok(numerator / denominator)
    }
}

fn main() {
    match divide(10, 2) {
        Ok(result) => println!("Result: {}", result),
        Err(e) => println!("Error: {}", e),
    }

    match divide(10, 0) {
        Ok(result) => println!("Result: {}", result),
        Err(e) => println!("Error: {}", e),
    }
}

In this Rust example, the divide function returns a Result type, ensuring that both success and error cases are handled explicitly. This makes the control flow predictable and avoids runtime crashes due to unhandled errors. By using the Result type, Rust enforces error handling at compile-time, ensuring that the developer has accounted for both the Ok and Err scenarios, leading to logically consistent and safer code.

In Haskell, the Either type is a standard way to handle errors in a functional way, allowing for composable error handling without breaking purity.

Example - Using `Either` in Haskell

divide :: Int -> Int -> Either String Int
divide _ 0 = Left "Division by zero error"
divide numerator denominator = Right (numerator `div` denominator)

main :: IO ()
main = do
  print (divide 10 2) -- Right 5
  print (divide 10 0) -- Left "Division by zero error"

In Haskell, the divide function returns an Either, which can be either Left for errors or Right for successful results. This explicit error handling is central to Haskell's functional paradigm, ensuring that errors are always accounted for. Since Either is part of the type signature, the compiler helps enforce correct usage, ensuring that every code path properly addresses both success and error cases.

How `Either` Improves Code Flow

The use of Either in functional programming offers several improvements to code flow compared to traditional error handling methods:

Explicit Error Handling: By returning an Either type, functions explicitly indicate that they can fail. This forces the caller to handle both success and failure cases, reducing the risk of unhandled errors and making the code more reliable.
Composability: With Either, functions can be composed easily using methods like flatMap. This allows for building complex workflows that handle errors at each step without interrupting the flow of the program. For example, chaining multiple operations that might fail becomes straightforward, as each step returns an Either that can be propagated or transformed.

   const parseNumber = (input: string): Either<number, string> => {
     const parsed = Number(input)
     return isNaN(parsed) ? Either.left("Invalid number") : Either.right(parsed)
   }

   const divideParsedNumber = (numerator: string, denominator: string): Either<number, string> => {
     return parseNumber(numerator).flatMap(num =>
       parseNumber(denominator).flatMap(den =>
         divide(num, den)
       )
     )
   }

   console.log(divideParsedNumber("10", "2")) // Either.right(5)
   console.log(divideParsedNumber("10", "0")) // Either.left("Division by zero error")
   console.log(divideParsedNumber("ten", "2")) // Either.left("Invalid number")

Pure Functions: Unlike exceptions, which can be thrown from anywhere and break the purity of functions, Either allows functions to remain pure. Pure functions are easier to test, debug, and reason about because they have no side effects and always produce the same output for the same input.
Type Safety: Either provides type safety by enforcing that all possible outcomes of a function are represented in the return type. This prevents errors from being ignored or missed, making the program more robust and reducing the likelihood of runtime errors. By using Algebraic Data Types (ADTs) like Either, the compiler enforces the handling of all potential outcomes, ensuring logical consistency and correctness. This is a significant improvement over traditional error handling methods, where errors could be easily ignored or forgotten.
Better Readability: By keeping both success and failure cases in the type signature, Either makes it clear what each function can return. This improves code readability and helps developers understand the possible outcomes without diving into the implementation details.
Compiler-Enforced Correctness: One of the biggest advantages of using Either is that the type system and the compiler work together to enforce error handling. The compiler will flag any use of an Either value where both success and failure branches are not properly handled, ensuring that developers cannot inadvertently forget to handle an error. This is in stark contrast to exceptions, where the absence of a try-catch can lead to runtime failures.

Checking Elements in Options in Effect-TS: A Practical Guide

Alessandro Maclaine — Wed, 18 Sep 2024 17:30:00 +0000

Effect-TS provides methods to check if an Option contains a specific value. These functions allow you to determine the presence of a value within an Option, either using a custom equivalence function or the default equivalence. In this article, we'll explore two key functions for checking elements in Options: O.containsWith and O.contains.

Example 1: Checking Elements with Custom Equivalence using `O.containsWith`

Concept

The O.containsWith function checks if an Option contains a specified value by using a custom equivalence function. This function returns true if the Option contains the value according to the provided equivalence; otherwise, it returns false.

Code

function elements_ex01() {
  const numberEquivalence = Eq.number;

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

  console.log(pipe(some1, O.containsWith(numberEquivalence)(1))); // Output: true (Option contains 1)
  console.log(pipe(some1, O.containsWith(numberEquivalence)(2))); // Output: false (Option does not contain 2)
  console.log(pipe(none, O.containsWith(numberEquivalence)(1))); // Output: false (Option is None)
}

Explanation

pipe(some1, O.containsWith(numberEquivalence)(1)): The Option contains the value 1, and the custom equivalence function confirms this, resulting in true.
pipe(some1, O.containsWith(numberEquivalence)(2)): The Option does not contain the value 2, so the result is false.
pipe(none, O.containsWith(numberEquivalence)(1)): The Option is None, so the result is false regardless of the value checked.

This function is useful when you need to check if an Option contains a specific value with a custom comparison logic, allowing for more flexibility in determining equivalence.

Example 2: Checking Elements with Default Equivalence using `O.contains`

Concept

The O.contains function checks if an Option contains a specified value using the default equivalence. It returns true if the Option contains the value; otherwise, it returns false. This function is simpler to use when you don't need custom comparison logic.

Code

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

  console.log(pipe(some1, O.contains(1))); // Output: true (Option contains 1)
  console.log(pipe(some1, O.contains(2))); // Output: false (Option does not contain 2)
  console.log(pipe(none, O.contains(1))); // Output: false (Option is None)
}

Explanation

pipe(some1, O.contains(1)): The Option contains the value 1, so the result is true.
pipe(some1, O.contains(2)): The Option does not contain the value 2, so the result is false.
pipe(none, O.contains(1)): The Option is None, so the result is false regardless of the value checked.

This function is useful for quickly checking if an Option contains a specific value when the default equivalence suffices, making it straightforward and easy to use.

Conclusion

Effect-TS provides efficient ways to check if an Option contains a specific value. With O.containsWith, you can use custom equivalence functions to define how the comparison should be made, offering flexibility for complex scenarios. Meanwhile, O.contains provides a simpler approach, leveraging the default equivalence for straightforward checks. These functions allow you to handle Options effectively, ensuring you can verify the presence of values in an intuitive and controlled manner.

Lifting Functions into the Option Context in Effect-TS: A Practical Guide

Alessandro Maclaine — Wed, 18 Sep 2024 16:54:27 +0000

In functional programming, lifting refers to the process of adapting a function to work within a specific context, such as an Option. Effect-TS provides convenient methods to lift functions into the Option context, allowing you to apply functions or predicates to Option values seamlessly. In this article, we'll explore two key functions for lifting: O.lift2 and O.liftPredicate.

Example 1: Lifting a Binary Function with `O.lift2`

Concept

The O.lift2 function allows you to lift a binary function (a function that takes two arguments) into the Option context. This enables you to apply the function to two Option values. If both Options are Some, the function is applied; if either Option is None, the result is None.

Code

function lifting_ex01() {
  const add = (a: number, b: number) => a + b;
  const liftedAdd = O.lift2(add);

  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, liftedAdd(some2))); // Output: Some(3) (1 + 2 = 3)
  console.log(pipe(some1, liftedAdd(none))); // Output: None (since one Option is None)
  console.log(pipe(none, liftedAdd(some2))); // Output: None (since one Option is None)
}

Explanation

pipe(some1, liftedAdd(some2)): Both Options are Some, so the add function is applied to the values, resulting in Some(3) (1 + 2 = 3).
pipe(some1, liftedAdd(none)): Since one of the Options is None, the result is None.
pipe(none, liftedAdd(some2)): Again, since one of the Options is None, the result is None.

This function is particularly useful when you want to apply a binary function to two Option values while handling the cases where one or both Options might be None.

Example 2: Lifting a Predicate Function with `O.liftPredicate`

Concept

The O.liftPredicate function allows you to lift a predicate (a function that returns a boolean) into the Option context. This converts the predicate into a function that returns an Option. If the predicate is satisfied, it returns Some with the value; otherwise, it returns None.

Code

function lifting_ex02() {
  const isPositive = (n: number) => n > 0;
  const liftedIsPositive = O.liftPredicate(isPositive);

  console.log(liftedIsPositive(1)); // Output: Some(1) (1 is positive)
  console.log(liftedIsPositive(-1)); // Output: None (-1 is not positive)
  console.log(liftedIsPositive(0)); // Output: None (0 is not positive)
}

Explanation

liftedIsPositive(1): The predicate isPositive is satisfied (1 > 0), so the result is Some(1).
liftedIsPositive(-1): The predicate is not satisfied (-1 is not greater than 0), so the result is None.
liftedIsPositive(0): The predicate is not satisfied (0 is not greater than 0), so the result is None.

This function is useful when you want to apply a predicate to a value and lift the result into the Option context, returning Some when the condition is met and None otherwise.

Conclusion

Lifting functions into the Option context in Effect-TS allows you to work seamlessly with optional values while applying functions or predicates. With O.lift2, you can apply binary functions to Options, ensuring that operations are only performed when both values are present. Similarly, O.liftPredicate enables you to convert predicates into functions that return an Option, making it easy to encapsulate conditions within the Option context. By using these tools, you can simplify your code and manage optional values more effectively in functional programming.

Equivalence and Ordering of Options in Effect-TS: A Practical Guide

Alessandro Maclaine — Wed, 18 Sep 2024 16:35:17 +0000

Effect-TS provides mechanisms to compare Options, allowing you to determine their equivalence or order based on the values they contain. These tools are useful when you need to check if two Options are equal or when you need to sort or compare them. In this article, we'll explore two key functions for comparing Options: O.getEquivalence and O.getOrder.

Example 1: Comparing Options for Equivalence with `O.getEquivalence`

Concept

The O.getEquivalence function creates an equivalence instance for Options, allowing you to compare the values inside them. It returns true if both Options are equivalent, meaning they either both contain the same value or are both None.

Code

function equivalence_ex01() {
  // Get the equivalence instance for numbers
  const optionEquivalence = O.getEquivalence(Eq.number);

  console.log(optionEquivalence(O.some(1), O.some(1))); // Output: true (both Options contain 1)
  console.log(optionEquivalence(O.some(1), O.some(2))); // Output: false (Options contain different values)
  console.log(optionEquivalence(O.none(), O.some(1))); // Output: false (one Option is None)
  console.log(optionEquivalence(O.none(), O.none())); // Output: true (both Options are None)
}

Explanation

optionEquivalence(O.some(1), O.some(1)): Both Options contain the value 1, so they are considered equivalent, resulting in true.
optionEquivalence(O.some(1), O.some(2)): The Options contain different values (1 and 2), so they are not equivalent, resulting in false.
optionEquivalence(O.none(), O.some(1)): One Option is None and the other contains a value, so they are not equivalent, resulting in false.
optionEquivalence(O.none(), O.none()): Both Options are None, so they are considered equivalent, resulting in true.

This function is useful when you need to check if two Options are the same, either by having the same value or both being None.

Example 2: Ordering Options with `O.getOrder`

Concept

The O.getOrder function creates an order instance for Options, allowing you to compare and determine their order. This function returns -1 if the first Option is less than the second, 1 if it is greater, and 0 if they are considered equal. None is considered less than Some.

Code

function order_ex01() {
  // Get the order instance for numbers
  const optionOrder = O.getOrder(Ord.number);

  console.log(optionOrder(O.some(1), O.some(2))); // Output: -1 (1 is less than 2)
  console.log(optionOrder(O.some(2), O.some(1))); // Output: 1 (2 is greater than 1)
  console.log(optionOrder(O.some(1), O.some(1))); // Output: 0 (both Options contain 1)
  console.log(optionOrder(O.none(), O.some(1))); // Output: -1 (None is less than Some)
  console.log(optionOrder(O.some(1), O.none())); // Output: 1 (Some is greater than None)
  console.log(optionOrder(O.none(), O.none())); // Output: 0 (both Options are None)
}

Explanation

optionOrder(O.some(1), O.some(2)): The value 1 is less than 2, so the function returns -1.
optionOrder(O.some(2), O.some(1)): The value 2 is greater than 1, so the function returns 1.
optionOrder(O.some(1), O.some(1)): Both Options contain the same value (1), so the function returns 0.
optionOrder(O.none(), O.some(1)): None is considered less than Some, so the function returns -1.
optionOrder(O.some(1), O.none()): Some is considered greater than None, so the function returns 1.
optionOrder(O.none(), O.none()): Both Options are None, so they are considered equal, and the function returns 0.

This function is helpful when you need to sort or compare Options, ensuring a consistent ordering even when some values might be None.

Conclusion

Effect-TS offers powerful tools for comparing Options through equivalence and ordering. With O.getEquivalence, you can determine if two Options are the same, either by containing the same value or both being None. Meanwhile, O.getOrder allows you to establish a clear ordering among Options, considering None as less than any Some value. These functions enable precise and consistent comparisons, making them essential tools for managing optional values in a functional programming context.

Filtering Options in Effect-TS: A Practical Guide

Alessandro Maclaine — Wed, 11 Sep 2024 17:19:18 +0000

Effect-TS provides various methods to filter values inside an Option, allowing you to apply transformations, predicates, or checks on the optional value. These functions help ensure that only relevant data is retained while discarding None values or those that don't meet specified conditions. In this article, we'll explore four key functions for filtering Options: O.partitionMap, O.filterMap, O.filter, and O.exists.

Example 1: Partitioning an Option with `O.partitionMap`

Concept

The O.partitionMap function allows you to partition an Option into a tuple of two Options based on a mapping function that returns an Either. The Either.left values are partitioned into the first Option, while Either.right values go into the second Option. If the original Option is None, both partitions are None.

Code

function filtering_ex01() {
  const some = O.some(1); // Create an Option containing the value 1
  const none = O.none(); // Create an Option representing no value
  const toEither = (n: number) => (n % 2 === 0 ? E.left(n) : E.right(n));

  console.log(pipe(some, O.partitionMap(toEither))); // Output: [None, Some(1)] (1 is odd, so it goes to the right)
  console.log(pipe(none, O.partitionMap(toEither))); // Output: [None, None] (since the Option is None)
}

Explanation

pipe(some, O.partitionMap(toEither)): Since 1 is odd, the toEither function returns E.right(1), placing 1 in the second Option, resulting in [None, Some(1)].
pipe(none, O.partitionMap(toEither)): Since the original Option is None, both partitions are None, resulting in [None, None].

This function is useful when you need to apply a mapping that categorizes values, while separating them into two groups—those that satisfy a condition and those that don't.

Example 2: Mapping and Filtering with `O.filterMap`

Concept

The O.filterMap function applies a transformation function to the value inside an Option. If the function returns Some, the value is retained; if it returns None, the value is filtered out. If the original Option is None, the result remains None.

Code

function filtering_ex02() {
  const some = O.some(1); // Create an Option containing the value 1
  const none = O.none(); // Create an Option representing no value
  const toEven = (n: number) => (n % 2 === 0 ? O.some(n) : O.none());

  console.log(pipe(some, O.filterMap(toEven))); // Output: None (since 1 is not even)
  console.log(pipe(O.some(2), O.filterMap(toEven))); // Output: Some(2) (since 2 is even)
  console.log(pipe(none, O.filterMap(toEven))); // Output: None (since the original Option is None)
}

Explanation

pipe(some, O.filterMap(toEven)): Since 1 is not even, the toEven function returns None, and the result is None.
pipe(O.some(2), O.filterMap(toEven)): The value 2 is even, so the toEven function returns Some(2), and the result is Some(2).
pipe(none, O.filterMap(toEven)): Since the original Option is None, the result remains None.

This function is helpful when you want to both transform and filter the value inside an Option based on specific conditions.

Example 3: Filtering an Option with a Predicate using `O.filter`

Concept

The O.filter function checks if the value inside an Option satisfies a given predicate. If the predicate is satisfied, it returns the original Option; otherwise, it returns None. If the original Option is None, it remains None.

Code

function filtering_ex03() {
  const some = O.some(1); // Create an Option containing the value 1
  const none = O.none(); // Create an Option representing no value
  const isEven = (n: number) => n % 2 === 0;

  console.log(pipe(some, O.filter(isEven))); // Output: None (since 1 is not even)
  console.log(pipe(O.some(2), O.filter(isEven))); // Output: Some(2) (since 2 is even)
  console.log(pipe(none, O.filter(isEven))); // Output: None (since the original Option is None)
}

Example 4: Checking a Predicate with `O.exists`

Concept

The O.exists function checks if a value inside an Option satisfies a predicate, returning true if it does, and false if it doesn't. If the Option is None, it returns false.

Code

function filtering_ex04() {
  const some = O.some(1); // Create an Option containing the value 1
  const none = O.none(); // Create an Option representing no value
  const isEven = (n: number) => n % 2 === 0;

  console.log(pipe(some, O.exists(isEven))); // Output: false (since 1 is not even)
  console.log(pipe(O.some(2), O.exists(isEven))); // Output: true (since 2 is even)
  console.log(pipe(none, O.exists(isEven))); // Output: false (since the original Option is None)
}

Explanation

pipe(some, O.exists(isEven)): Since 1 is not even, the predicate is not satisfied, so the result is false.
pipe(O.some(2), O.exists(isEven)): The value 2 satisfies the predicate, so the result is true.
pipe(none, O.exists(isEven)): Since the Option is None, the result is false.

This function is useful when you need a quick check to determine if the value inside an Option satisfies a condition without transforming or filtering the Option itself.

Conclusion

Filtering Options in Effect-TS allows for flexible handling of optional values based on conditions or transformations. Whether you're partitioning values with O.partitionMap, applying transformations with O.filterMap, checking predicates with O.filter, or simply verifying conditions with O.exists, these tools provide robust methods for controlling how Options are handled. By using these functions, you can manage optional data efficiently, ensuring only the relevant values are kept or acted upon.

Folding Options in Effect-TS: A Practical Guide

Alessandro Maclaine — Wed, 11 Sep 2024 17:02:49 +0000

Effect-TS provides efficient ways to work with collections of Options, allowing you to perform operations on only the non-None values. One such operation is folding, where values are combined into a single result. In this article, we'll explore the O.reduceCompact function, which reduces an iterable of Options by applying a reducing function to the non-None values.

Example 1: Reducing an Iterable of Options with `O.reduceCompact`

Concept

The O.reduceCompact function takes an iterable of Options and reduces them to a single value by applying a reducing function to the non-None values. If an Option is None, it is ignored in the reduction.

Code

function folding_ex01() {
  const options = [O.some(1), O.none(), O.some(2), O.none(), O.some(3)]; // Create an iterable of Options
  const sum = (acc: number, value: number) => acc + value;

  console.log(pipe(options, O.reduceCompact(0, sum))); // Output: 6 (sums all non-None values: 1 + 2 + 3)
}

Explanation

pipe(options, O.reduceCompact(0, sum)): The function starts with an initial value of 0 and iterates over the array of Options. It applies the sum function to the non-None values, accumulating the result. In this case, it adds 1, 2, and 3, resulting in 6. Any None values are ignored in the process.

This function is useful when you need to aggregate values from an iterable of Options, ensuring only the non-None values are considered.

Conclusion

Folding Options with O.reduceCompact in Effect-TS provides a powerful way to aggregate values while skipping over None values. This ensures that only meaningful values are considered in the reduction process, making it an effective tool for safely combining optional data. By leveraging this function, you can cleanly and efficiently process collections of Options without needing to handle None values explicitly in your logic.

Combining Options in Effect-TS: A Practical Guide

Alessandro Maclaine — Wed, 11 Sep 2024 16:53:19 +0000

Effect-TS provides several powerful ways to combine optional values, or Options, in a functional programming context. Whether you want to pair multiple Options together or apply functions inside Options to other values, the library offers several methods to simplify these operations. In this article, we'll explore four key functions for combining Options: O.product, O.productMany, O.all, and O.ap.

Example 1: Combining Two Options into a Tuple with `O.product`

Concept

The O.product function allows you to combine two Options into a tuple. If both Options are Some, it returns an Option containing the tuple of both values. If either Option is None, it returns None.

Code

function combining_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(O.product(some1, some2)); // Output: Some([1, 2]) (combines both values into a tuple)
  console.log(O.product(some1, none)); // Output: None (since the second Option is None)
  console.log(O.product(none, some2)); // Output: None (since the first Option is None)
}

Explanation

O.product(some1, some2): Both some1 and some2 are Some, so the function returns Some([1, 2]), a tuple containing both values.
O.product(some1, none): Since the second Option is None, the function returns None.
O.product(none, some2): Since the first Option is None, the function returns None.

This function is useful when you need to combine the values of two Options into a pair, but you still want to ensure both values exist before proceeding.

Example 2: Combining Multiple Options into a Tuple with `O.productMany`

Concept

The O.productMany function allows you to combine one Option with multiple Options, producing a tuple if all Options are Some. If any of the Options is None, the function returns None.

Code

function combining_ex02() {
  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 some3 = O.some(3); // Create an Option containing the value 3
  const none = O.none(); // Create an Option representing no value

  console.log(O.productMany(some1, [some2, some3])); // Output: Some([1, 2, 3]) (combines all values into a tuple)
  console.log(O.productMany(some1, [none, some3])); // Output: None (since one of the Options is None)
}

Explanation

O.productMany(some1, [some2, some3]): All the Options are Some, so the function returns Some([1, 2, 3]), combining all values into a tuple.
O.productMany(some1, [none, some3]): Since one of the Options is None, the function returns None.

This function is useful when you need to combine multiple Options into a single tuple but want to ensure that all values are present before proceeding.

Example 3: Combining a Structure of Options with `O.all`

Concept

The O.all function combines multiple Options from an array or an object into a single Option. If all Options are Some, it returns a new Option containing the combined structure. If any Option is None, it returns None.

Code

function combining_ex03() {
  const optionsArray = [O.some(1), O.some(2), O.some(3)]; // Create an array of Options
  const optionsArrayWithNone = [O.some(1), O.none(), O.some(3)]; // Create an array of Options with a None
  const optionsObject = { a: O.some(1), b: O.some(2) }; // Create an object of Options
  const optionsObjectWithNone = { a: O.some(1), b: O.none() }; // Create an object of Options with a None

  console.log(O.all(optionsArray)); // Output: Some([1, 2, 3]) (combines all array values)
  console.log(O.all(optionsArrayWithNone)); // Output: None (since one of the array Options is None)
  console.log(O.all(optionsObject)); // Output: Some({ a: 1, b: 2 }) (combines all object values)
  console.log(O.all(optionsObjectWithNone)); // Output: None (since one of the object Options is None)
}

Explanation

O.all(optionsArray): All the Options in the array are Some, so the function returns Some([1, 2, 3]), combining all array values.
O.all(optionsArrayWithNone): One of the Options in the array is None, so the function returns None.
O.all(optionsObject): All the Options in the object are Some, so the function returns Some({ a: 1, b: 2 }), combining all object values.
O.all(optionsObjectWithNone): One of the Options in the object is None, so the function returns None.

This function is useful when dealing with multiple Options in a structure, and you want to ensure all values are present before combining them.

Example 4: Applying a Function in an Option with `O.ap`

Concept

The O.ap function allows you to apply a function contained in one Option to a value contained in another Option. If both Options are Some, it returns an Option containing the result of applying the function. If either Option is None, it returns None.

Code

function combining_ex04() {
  const someFn = O.some((n: number) => n * 2); // Create an Option containing a function
  const someValue = O.some(3); // Create an Option containing the value 3
  const none = O.none(); // Create an Option representing no value

  console.log(pipe(someFn, O.ap(someValue))); // Output: Some(6) (applies the function to the value)
  console.log(pipe(someFn, O.ap(none))); // Output: None (since the value Option is None)
  console.log(pipe(none, O.ap(someValue))); // Output: None (since the function Option is None)
}

Explanation

pipe(someFn, O.ap(someValue)): Both Options are Some, so the function is applied to the value, resulting in Some(6).
pipe(someFn, O.ap(none)): Since the value Option is None, the function returns None.
pipe(none, O.ap(someValue)): Since the function Option is None, the result is None.

This function is useful when you need to apply a function wrapped in an Option to a value also wrapped in an Option, ensuring both exist before performing the operation.

Conclusion

Combining Options in Effect-TS allows for robust handling of optional values in a functional style. Whether you're creating tuples with O.product, combining multiple Options with O.productMany, merging structures with O.all, or applying functions with O.ap, these techniques ensure your operations are safe and predictable. By leveraging these methods, you can simplify your code while maintaining safety around missing values, making your logic more concise and reliable.

Zipping Options in Effect-TS: A Practical Guide

Alessandro Maclaine — Wed, 28 Aug 2024 18:09:11 +0000

Zipping Options in Effect-TS: A Practical Guide

In functional programming, combining multiple optional values (represented as Options) in a safe and predictable way is a common task. Effect-TS provides several methods to "zip" Options together, allowing you to combine their values or select one based on specific rules. In this article, we'll explore three key functions for zipping Options: O.zipRight, O.zipLeft, and O.zipWith.

Example 1: Returning the Second Option with `O.zipRight`

Concept

The O.zipRight function allows you to combine two Options, discarding the first and returning the second. This operation succeeds if both Options are Some; otherwise, it returns None.

Code

function zipping_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.zipRight(some2))); // Output: Some(2) (returns the second Option)
  console.log(pipe(some1, O.zipRight(none))); // Output: None (since the second Option is None)
  console.log(pipe(none, O.zipRight(some2))); // Output: None (since the first Option is None)
}

Explanation

pipe(some1, O.zipRight(some2)): Both some1 and some2 are Some, so the function returns the second Option, which is Some(2).
pipe(some1, O.zipRight(none)): Since the second Option is None, the function returns None.
pipe(none, O.zipRight(some2)): The first Option is None, so the function returns None, regardless of the second Option.

This function is particularly useful when you want to perform an operation where the result is dependent solely on the second Option.

Example 2: Returning the First Option with `O.zipLeft`

Concept

The O.zipLeft function is the counterpart to O.zipRight, allowing you to combine two Options while discarding the second and returning the first. Again, this operation succeeds if both Options are Some; otherwise, it returns None.

Code

function zipping_ex02() {
  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.zipLeft(some2))); // Output: Some(1) (returns the first Option)
  console.log(pipe(some1, O.zipLeft(none))); // Output: None (since the second Option is None)
  console.log(pipe(none, O.zipLeft(some2))); // Output: None (since the first Option is None)
}

Explanation

pipe(some1, O.zipLeft(some2)): Since both Options are Some, the function returns the first Option, which is Some(1).
pipe(some1, O.zipLeft(none)): The second Option is None, so the function returns None.
pipe(none, O.zipLeft(some2)): Since the first Option is None, the function returns None.

This function is useful when the outcome should be determined by the first Option, but you still want to ensure the second Option is valid.

Example 3: Combining Options with a Function using `O.zipWith`

Concept

The O.zipWith function provides the most flexibility, allowing you to combine the values of two Options using a provided function. If both Options are Some, the function is applied, and the result is wrapped in a new Option. If either Option is None, the function returns None.

Code

function zipping_ex03() {
  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
  const add = (a: number, b: number) => a + b;

  console.log(pipe(some1, O.zipWith(some2, add))); // Output: Some(3) (since 1 + 2 = 3)
  console.log(pipe(some1, O.zipWith(none, add))); // Output: None (since the second Option is None)
  console.log(pipe(none, O.zipWith(some2, add))); // Output: None (since the first Option is None)
}

Explanation

pipe(some1, O.zipWith(some2, add)): Both Options are Some, so the add function is applied, resulting in Some(3).
pipe(some1, O.zipWith(none, add)): Since the second Option is None, the function returns None.
pipe(none, O.zipWith(some2, add)): The first Option is None, so the function returns None.

This function is ideal when you need to perform an operation on the values of two Options, as it ensures that both values are present before the operation is performed.

Conclusion

Zipping Options in Effect-TS is a powerful way to combine optional values safely. Whether you're interested in the first Option, the second, or a combination of both, the O.zipRight, O.zipLeft, and O.zipWith functions provide the tools you need to handle these scenarios efficiently. By understanding and applying these patterns, you can write more robust and predictable functional code.

Understanding Option Sequencing in Effect-TS

Alessandro Maclaine — Wed, 28 Aug 2024 17:35:49 +0000

Example 1: Ignoring the First Value with `O.andThen`

Concept

The O.andThen function allows you to execute a sequence of two Options, where the result is determined solely by the second Option. This is useful when the first Option serves a purpose, but its value isn't needed in subsequent operations.

Code

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)
}

Explanation

pipe(some1, O.andThen(some2)): Here, some1 holds the value 1, but the operation ignores it and returns some2, which holds 2.
pipe(none, O.andThen(some2)): Since the first Option is None, the operation short-circuits and returns None.

This sequencing operation is particularly useful when you want to chain operations but are only interested in the outcome of the second operation.

Example 2: Flattening Nested Options with `O.flatten`

Concept

The O.flatten function is designed to handle nested Options by removing one level of nesting. This is useful when your operations result in an Option of Option, and you need to simplify it into a single Option.

Code

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)
}

Explanation

pipe(nestedSome, O.flatten): This flattens the Option of Option into a single Option, resulting in Some(1).
pipe(nestedNone, O.flatten): The inner Option is None, so flattening results in None.
pipe(none, O.flatten): If the outer Option is None, flattening has no effect, and None is returned.

Flattening is essential when dealing with functions that may return nested Options, allowing you to streamline the result into a single Option value.

Example 3: Composing Option-returning Functions with `O.composeK`

Concept

The O.composeK function allows you to compose two functions that return an Option, creating a pipeline where the output of the first function is fed into the second. This is particularly useful for chaining operations that may fail and result in None.

Code

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

  const doubleIfPositive = (n: number): O.Option<number> =>
    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)
}

Explanation

parseAndDouble('42'): The string '42' is successfully parsed to a number, and since it’s positive, it’s doubled, resulting in Some(84).
parseAndDouble('-1'): The string '-1' is parsed, but since it’s negative, the function returns None.
parseAndDouble('abc'): The string 'abc' cannot be parsed as a number, so the function returns None.

Composing Option-returning functions allows you to create complex chains of operations while safely handling cases where any step in the chain may fail.

Conclusion

These examples showcase the versatility and power of the Option type in Effect-TS for handling sequences of operations. Whether you're ignoring values with O.andThen, flattening nested Options with O.flatten, or composing operations with O.composeK, these patterns enable you to manage optional values more effectively in a functional programming context. By leveraging these techniques, you can write more robust and concise code, ensuring that operations gracefully handle the absence of values while maintaining clear and readable logic.

Mapping Operations in Effect-TS Optionals

Alessandro Maclaine — Mon, 22 Jul 2024 16:17:42 +0000

In Effect-TS, various mapping functions can be applied to the values inside an Option to transform, replace, or manipulate the contained values. This article explores different mapping functions provided by Effect-TS with practical examples.

Example 1: Basic Mapping with `O.map`

Use O.map to apply a transformation function to the value inside an Option. If the Option is Some, the function is applied; otherwise, the result is None.

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

function mapping_ex01() {
  const some = O.some(1); // Create an Option containing the value 1
  const none = O.none(); // Create an Option representing no value
  const increment = (n: number) => n + 1;

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

Example 2: Mapping to a Constant Value with `O.as`

Use O.as to replace the value inside the Option with a provided constant value.

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

function mapping_ex02() {
  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.as('replaced'))); // Output: Some('replaced') (replaces 1 with 'replaced')
  console.log(pipe(none, O.as('replaced'))); // Output: None (since none is None)
}

Explanation:

Creating Options: We create two Options, one containing a value (some with 1) and another representing no value (none).
Applying O.as: We use O.as to replace the value inside the Option with the constant value 'replaced'.

The output is Some('replaced') for the some Option and None for the none Option, demonstrating how O.as effectively replaces the original value if it exists.

Example 3: Mapping to `void` with `O.asVoid`

Use O.asVoid to replace the value inside the Option with undefined.

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

function mapping_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.asVoid)); // Output: Some(undefined) (replaces 1 with undefined)
  console.log(pipe(none, O.asVoid)); // Output: None (since none is None)
}

Explanation:

Creating Options: We create two Options, one containing a value (some with 1) and another representing no value (none).
Applying O.asVoid: We use O.asVoid to replace the value inside the Option with undefined.

The output is Some(undefined) for the some Option and None for the none Option, demonstrating how O.asVoid effectively replaces the original value if it exists.

Example 4: FlatMapping with `O.flatMap`

Use O.flatMap to apply a transformation function that returns an Option to the value if the Option is Some, and flatten the result.

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

function mapping_ex04() {
  const some = O.some(1); // Create an Option containing the value 1
  const none = O.none(); // Create an Option representing no value
  const doubleIfPositive = (n: number) => (n > 0 ? O.some(n * 2) : O.none());

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

Explanation:

Creating Options: We create two Options, one containing a value (some with 1) and another representing no value (none).
Applying O.flatMap: We use O.flatMap to apply a transformation function (doubleIfPositive) that returns an Option. If the value is positive, it doubles the value and wraps it in Some, otherwise it returns None.

The output is Some(2) for the some Option and None for the none Option, demonstrating how O.flatMap flattens the result of the transformation.

Example 5: FlatMapping Nullable Values with `O.flatMapNullable`

Use O.flatMapNullable to apply a transformation function that may return a nullable value to the value if the Option is Some, and convert the result to an Option.

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

function mapping_ex05() {
  const some = O.some({ a: { b: { c: 1 } } }); // Create an Option containing a nested object
  const none = O.none(); // Create an Option representing no value
  const getCValue = (obj: { a?: { b?: { c?: number } } }) => obj.a?.b?.c ?? null;

  console.log(pipe(some, O.flatMapNullable(getCValue))); // Output: Some(1) (extracts the nested value)
  console.log(pipe(none, O.flatMapNullable(getCValue))); // Output: None (since none is None)
}

Explanation:

Creating Options: We create two Options, one containing a nested object (some) and another representing no value (none).
Applying O.flatMapNullable: We use O.flatMapNullable to apply a transformation function (getCValue) that extracts a nested value and may return null. The function returns Some if a value is found, otherwise it returns None.

The output is Some(1) for the some Option and None for the none Option, demonstrating how O.flatMapNullable converts the result of the transformation to an Option.

Using do Notation in Effect-TS Optionals

Alessandro Maclaine — Mon, 22 Jul 2024 16:03:12 +0000

Effect-TS provides a powerful way to handle operations within the Option context using the do notation. This article explores how to sequence multiple operations with do notation and demonstrates various scenarios through examples.

Example 1: Basic Sequencing and Filtering

In this example, we bind values within the Option context, compute a sum, and filter based on a condition.

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

function do_ex01() {
  const result = pipe(
    O.Do,
    O.bind('x', () => O.some(2)), // Bind x to the value 2 wrapped in Some
    O.bind('y', () => O.some(3)), // Bind y to the value 3 wrapped in Some
    O.let('sum', ({ x, y }) => x + y), // Let sum be the sum of x and y
    O.filter(({ x, y }) => x * y > 5) // Filter the result if x * y > 5
  );
  console.log(result); // Output: Some({ x: 2, y: 3, sum: 5 }) (since 2 * 3 > 5)
}

Explanation:

Binding Values: We bind x to 2 and y to 3, both wrapped in Some.
Computing Sum: We compute sum as the sum of x and y.
Filtering: We filter the result based on the condition x * y > 5.

The output is Some({ x: 2, y: 3, sum: 5 }) because the condition 2 * 3 > 5 is met.

Example 2: Filtering with a Failing Condition

This example shows that if the filter condition fails, the result is None.

function do_ex02() {
  const result = pipe(
    O.Do,
    O.bind('x', () => O.some(1)), // Bind x to the value 1 wrapped in Some
    O.bind('y', () => O.some(2)), // Bind y to the value 2 wrapped in Some
    O.let('sum', ({ x, y }) => x + y), // Let sum be the sum of x and y
    O.filter(({ x, y }) => x * y > 5) // Filter the result if x * y > 5
  );
  console.log(result); // Output: None (since 1 * 2 <= 5)
}

Explanation:

Binding Values: We bind x to 1 and y to 2.
Computing Sum: We compute sum as the sum of x and y.
Filtering: We filter the result based on the condition x * y > 5.

The output is None because the condition 1 * 2 <= 5 fails.

Example 3: Binding with None

This example demonstrates that if any binding is None, the result is None.

function do_ex03() {
  const result = pipe(
    O.Do,
    O.bind('x', () => O.some(2)), // Bind x to the value 2 wrapped in Some
    O.bind('y', () => O.none()), // Bind y to None
    O.let('sum', ({ x, y }) => x + y), // This line won't execute since y is None
    O.filter(({ x, y }) => x * y > 5) // This line won't execute since y is None
  );
  console.log(result); // Output: None (since y is `None`)
}

Explanation:

Binding Values: We bind x to 2 and y to None.
Skipping Computation and Filtering: Since y is None, the subsequent operations are skipped.

The output is None because one of the bindings (y) isNone`.

Summary

The do notation in Effect-TS allows for elegant and readable sequencing of operations within the Option context. By binding values, letting computed values, and filtering based on conditions, we can handle complex optional logic in a straightforward manner. The examples above illustrate how the result changes based on different conditions and the presence of None.

Exploring Option Conversions in Effect-TS

Alessandro Maclaine — Tue, 16 Jul 2024 18:05:41 +0000

Effect-TS provides powerful tools for handling Option and Either types. In this article, we'll explore various ways to convert and manipulate these types using the library's utility functions.

Example 1: Convert an Either to an Option with `O.getRight`

The O.getRight function converts an Either to an Option, discarding the error. If the Either is Right, it returns O.some(value), otherwise it returns 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
}

Example 2: Convert an Either to an Option with `O.getLeft`

The O.getLeft function converts an Either to an Option, discarding the value. If the Either is Left, it returns O.some(error), otherwise it returns 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')
}

Example 3: Get Value or Default with `O.getOrElse`

The O.getOrElse function returns the value inside the Option if it is Some, otherwise, it returns the provided default value.

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)
}

Example 4: Chaining Options with `O.orElse`

The O.orElse function returns the provided Option that if self is None, otherwise it returns self. This function allows chaining of Options where the fallback is another Option.

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)
}

Example 5: Fallback to a Default Value with `O.orElseSome`

The O.orElseSome function returns the provided default value wrapped in Some if self is None, otherwise it returns self. This function allows chaining of Options where the fallback is a default value wrapped in 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)
}

Example 6: Chaining Options with Either Context using `O.orElseEither`

The O.orElseEither function returns an Option containing an Either where Left is from the fallback Option and Right is from the original Option. This function allows chaining of Options where the fallback provides an Either for more context.

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)
}

Example 7: Find the First `Some` in an Iterable with `O.firstSomeOf`

The O.firstSomeOf function returns the first Some found in an iterable of Options. If all are None, it returns None.

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)
}

Example 8: Convert a Function Returning an Option to a Type Guard with `O.toRefinement`

The O.toRefinement function converts a function returning an Option to a type guard, allowing more specific type checking.

import { Option as O } from 'effect';

function conversions_ex08() {
  const isPositive = (n: number): O.Option<number> => 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)
}

Example 9: Convert an Option to an Array with `O.toArray`

The O.toArray function converts an Option to an array. If the Option is Some, it returns an array containing the value; if it is None, it returns an empty array.

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)
}

Conclusion

In this article, we've explored various functions provided by Effect-TS for converting and manipulating Option and Either types. These functions enhance the flexibility and expressiveness of your code, allowing you to handle optional and error-prone values more gracefully. Whether you need to convert an Either to an Option, chain multiple Option values, or perform type-safe operations, Effect-TS offers a robust set of tools to simplify these tasks. By leveraging these utilities, you can write cleaner, more maintainable code that effectively handles the presence or absence of values.

DEV Community: Alessandro Maclaine

Either Algebraic Data Type

Motivation and Role of Either in Functional Programming

Key Benefits of Either

Comparison with Other Error Handling Methods

Return Codes (C)

Example - Return Codes in C

Exceptions (OOP Languages)

Example - Exceptions in Java

Either in Functional Programming

Example - Using Either in TypeScript

Rust and Haskell

Example - Using Result in Rust

Example - Using Either in Haskell

How Either Improves Code Flow

Checking Elements in Options in Effect-TS: A Practical Guide

Example 1: Checking Elements with Custom Equivalence using O.containsWith

Concept

Code

Explanation

Example 2: Checking Elements with Default Equivalence using O.contains

Concept

Code

Explanation

Conclusion

Lifting Functions into the Option Context in Effect-TS: A Practical Guide

Example 1: Lifting a Binary Function with O.lift2

Concept

Code

Explanation

Example 2: Lifting a Predicate Function with O.liftPredicate

Concept

Code

Explanation

Conclusion

Equivalence and Ordering of Options in Effect-TS: A Practical Guide

Example 1: Comparing Options for Equivalence with O.getEquivalence

Concept

Code

Explanation

Example 2: Ordering Options with O.getOrder

Concept

Code

Explanation

Conclusion

Filtering Options in Effect-TS: A Practical Guide

Example 1: Partitioning an Option with O.partitionMap

Concept

Code

Explanation

Example 2: Mapping and Filtering with O.filterMap

Concept

Code

Explanation

Example 3: Filtering an Option with a Predicate using O.filter

Concept

Code

Example 4: Checking a Predicate with O.exists

Concept

Code

Explanation

Conclusion

Folding Options in Effect-TS: A Practical Guide

Example 1: Reducing an Iterable of Options with O.reduceCompact

Concept

Code

Explanation

Conclusion

Combining Options in Effect-TS: A Practical Guide

Example 1: Combining Two Options into a Tuple with O.product

Concept

Code

Explanation

Example 2: Combining Multiple Options into a Tuple with O.productMany

Concept

Code

Explanation

Example 3: Combining a Structure of Options with O.all

Concept

Code

Motivation and Role of `Either` in Functional Programming

Key Benefits of `Either`

`Either` in Functional Programming

Example - Using `Either` in TypeScript

Example - Using `Result` in Rust

Example - Using `Either` in Haskell

How `Either` Improves Code Flow

Example 1: Checking Elements with Custom Equivalence using `O.containsWith`

Example 2: Checking Elements with Default Equivalence using `O.contains`

Example 1: Lifting a Binary Function with `O.lift2`

Example 2: Lifting a Predicate Function with `O.liftPredicate`

Example 1: Comparing Options for Equivalence with `O.getEquivalence`

Example 2: Ordering Options with `O.getOrder`

Example 1: Partitioning an Option with `O.partitionMap`

Example 2: Mapping and Filtering with `O.filterMap`

Example 3: Filtering an Option with a Predicate using `O.filter`

Example 4: Checking a Predicate with `O.exists`

Example 1: Reducing an Iterable of Options with `O.reduceCompact`

Example 1: Combining Two Options into a Tuple with `O.product`

Example 2: Combining Multiple Options into a Tuple with `O.productMany`

Example 3: Combining a Structure of Options with `O.all`

Example 4: Applying a Function in an Option with `O.ap`

Example 1: Returning the Second Option with `O.zipRight`

Example 2: Returning the First Option with `O.zipLeft`

Example 3: Combining Options with a Function using `O.zipWith`

Example 1: Ignoring the First Value with `O.andThen`

Example 2: Flattening Nested Options with `O.flatten`

Example 3: Composing Option-returning Functions with `O.composeK`

Example 1: Basic Mapping with `O.map`

Example 2: Mapping to a Constant Value with `O.as`

Example 3: Mapping to `void` with `O.asVoid`

Example 4: FlatMapping with `O.flatMap`

Example 5: FlatMapping Nullable Values with `O.flatMapNullable`

Example 1: Convert an Either to an Option with `O.getRight`

Example 2: Convert an Either to an Option with `O.getLeft`

Example 3: Get Value or Default with `O.getOrElse`

Example 4: Chaining Options with `O.orElse`

Example 5: Fallback to a Default Value with `O.orElseSome`

Example 6: Chaining Options with Either Context using `O.orElseEither`

Example 7: Find the First `Some` in an Iterable with `O.firstSomeOf`

Example 8: Convert a Function Returning an Option to a Type Guard with `O.toRefinement`

Example 9: Convert an Option to an Array with `O.toArray`