## DEV Community

Alessandro Maclaine

Posted on

# Mapping Operations in Effect-TS Optionals

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:

1. Creating Options: We create two Options, one containing a value (`some` with 1) and another representing no value (`none`).
2. 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:

1. Creating Options: We create two Options, one containing a value (`some` with 1) and another representing no value (`none`).
2. 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:

1. Creating Options: We create two Options, one containing a value (`some` with 1) and another representing no value (`none`).
2. 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:

1. Creating Options: We create two Options, one containing a nested object (`some`) and another representing no value (`none`).
2. 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.