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) is`

None`.

## 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.

## Top comments (0)