Building Pipelines

Effect pipelines allow for the composition and sequencing of operations on values, enabling the transformation and manipulation of data in a concise and modular manner.

Why Pipelines are Good for Structuring Your Application

Pipelines are an excellent way to structure your application and handle data transformations in a concise and modular manner. They offer several benefits:

Readability: Pipelines allow you to compose functions in a readable and sequential manner. You can clearly see the flow of data and the operations applied to it, making it easier to understand and maintain the code.
Code Organization: With pipelines, you can break down complex operations into smaller, manageable functions. Each function performs a specific task, making your code more modular and easier to reason about.
Reusability: Pipelines promote the reuse of functions. By breaking down operations into smaller functions, you can reuse them in different pipelines or contexts, improving code reuse and reducing duplication.
Type Safety: By leveraging the type system, pipelines help catch errors at compile-time. Functions in a pipeline have well-defined input and output types, ensuring that the data flows correctly through the pipeline and minimizing runtime errors.

Functions vs Methods

The use of functions in the Effect ecosystem libraries is important for achieving tree shakeability and ensuring extensibility. Functions enable efficient bundling by eliminating unused code, and they provide a flexible and modular approach to extending the libraries’ functionality.

Tree Shakeability

Tree shakeability refers to the ability of a build system to eliminate unused code during the bundling process. Functions are tree shakeable, while methods are not.

When functions are used in the Effect ecosystem, only the functions that are actually imported and used in your application will be included in the final bundled code. Unused functions are automatically removed, resulting in a smaller bundle size and improved performance.

On the other hand, methods are attached to objects or prototypes, and they cannot be easily tree shaken. Even if you only use a subset of methods, all methods associated with an object or prototype will be included in the bundle, leading to unnecessary code bloat.

Extensibility

Another important advantage of using functions in the Effect ecosystem is the ease of extensibility. With methods, extending the functionality of an existing API often requires modifying the prototype of the object, which can be complex and error-prone.

In contrast, with functions, extending the functionality is much simpler. You can define your own “extension methods” as plain old functions without the need to modify the prototypes of objects. This promotes cleaner and more modular code, and it also allows for better compatibility with other libraries and modules.

pipe

The pipe function is a utility that allows us to compose functions in a readable and sequential manner. It takes the output of one function and passes it as the input to the next function in the pipeline. This enables us to build complex transformations by chaining multiple functions together.

Syntax

import { pipe } from "effect"

const result = pipe(input, func1, func2, ..., funcN)

In this syntax, input is the initial value, and func1, func2, …, funcN are the functions to be applied in sequence. The result of each function becomes the input for the next function, and the final result is returned.

Here’s an illustration of how pipe works:

┌───────┐    ┌───────┐    ┌───────┐    ┌───────┐    ┌───────┐    ┌────────┐
│ input │───►│ func1 │───►│ func2 │───►│  ...  │───►│ funcN │───►│ result │
└───────┘    └───────┘    └───────┘    └───────┘    └───────┘    └────────┘

It’s important to note that functions passed to pipe must have a single argument because they are only called with a single argument.

Let’s see an example to better understand how pipe works:

Example (Chaining Arithmetic Operations)

1
import { pipe } from "effect"
2

3
// Define simple arithmetic operations
4
const increment = (x: number) => x + 1
5
const double = (x: number) => x * 2
6
const subtractTen = (x: number) => x - 10
7

8
// Sequentially apply these operations using `pipe`
9
const result = pipe(5, increment, double, subtractTen)
10

11
console.log(result)
12
// Output: 2

In the above example, we start with an input value of 5. The increment function adds 1 to the initial value, resulting in 6. Then, the double function doubles the value, giving us 12. Finally, the subtractTen function subtracts 10 from 12, resulting in the final output of 2.

The result is equivalent to subtractTen(double(increment(5))), but using pipe makes the code more readable because the operations are sequenced from left to right, rather than nesting them inside out.

map

Transforms the value inside an effect by applying a function to it.

Syntax

const mappedEffect = pipe(myEffect, Effect.map(transformation))
// or
const mappedEffect = Effect.map(myEffect, transformation)
// or
const mappedEffect = myEffect.pipe(Effect.map(transformation))

Effect.map takes a function and applies it to the value contained within an effect, creating a new effect with the transformed value.

Example (Adding a Service Charge)

Here’s a practical example where we apply a service charge to a transaction amount:

1
import { pipe, Effect } from "effect"
2

3
// Function to add a small service charge to a transaction amount
4
const addServiceCharge = (amount: number) => amount + 1
5

6
// Simulated asynchronous task to fetch a transaction amount from database
7
const fetchTransactionAmount = Effect.promise(() => Promise.resolve(100))
8

9
// Apply service charge to the transaction amount
10
const finalAmount = pipe(fetchTransactionAmount, Effect.map(addServiceCharge))
11

12
Effect.runPromise(finalAmount).then(console.log) // Output: 101

as

Replaces the value inside an effect with a constant value.

Effect.as allows you to ignore the original value inside an effect and replace it with a new constant value.

Example (Replacing a Value)

1
import { pipe, Effect } from "effect"
2

3
// Replace the value 5 with the constant "new value"
4
const program = pipe(Effect.succeed(5), Effect.as("new value"))
5

6
Effect.runPromise(program).then(console.log) // Output: "new value"

flatMap

Chains effects to produce new Effect instances, useful for combining operations that depend on previous results.

Syntax

const flatMappedEffect = pipe(myEffect, Effect.flatMap(transformation))
// or
const flatMappedEffect = Effect.flatMap(myEffect, transformation)
// or
const flatMappedEffect = myEffect.pipe(Effect.flatMap(transformation))

In the code above, transformation is the function that takes a value and returns an Effect, and myEffect is the initial Effect being transformed.

Use Effect.flatMap when you need to chain multiple effects, ensuring that each step produces a new Effect while flattening any nested effects that may occur.

It is similar to flatMap used with arrays but works specifically with Effect instances, allowing you to avoid deeply nested effect structures.

Example (Applying a Discount)

1
import { pipe, Effect } from "effect"
2

3
// Function to apply a discount safely to a transaction amount
4
const applyDiscount = (total: number, discountRate: number): Effect.Effect<number, Error> =>
5
  discountRate === 0
6
    ? Effect.fail(new Error("Discount rate cannot be zero"))
7
    : Effect.succeed(total - (total * discountRate) / 100)
8

9
// Simulated asynchronous task to fetch a transaction amount from database
10
const fetchTransactionAmount = Effect.promise(() => Promise.resolve(100))
11

12
// Chaining the fetch and discount application using `flatMap`
13
const finalAmount = pipe(
14
  fetchTransactionAmount,
15
  Effect.flatMap((amount) => applyDiscount(amount, 5)),
16
)
17

18
Effect.runPromise(finalAmount).then(console.log)
19
// Output: 95

Ensure All Effects Are Considered

Make sure that all effects within Effect.flatMap contribute to the final computation. If you ignore an effect, it can lead to unexpected behavior:

Effect.flatMap((amount) => {
  // This effect will be ignored
  Effect.sync(() => console.log(`Apply a discount to: ${amount}`))
  return applyDiscount(amount, 5)
})

In this case, the Effect.sync call is ignored and does not affect the result of applyDiscount(amount, 5). To handle effects correctly, make sure to explicitly chain them using functions like Effect.map, Effect.flatMap, Effect.andThen, or Effect.tap.

andThen

Chains two actions, where the second action can depend on the result of the first.

Syntax

const transformedEffect = pipe(myEffect, Effect.andThen(anotherEffect))
// or
const transformedEffect = Effect.andThen(myEffect, anotherEffect)
// or
const transformedEffect = myEffect.pipe(Effect.andThen(anotherEffect))

Use andThen when you need to run multiple actions in sequence, with the second action depending on the result of the first. This is useful for combining effects or handling computations that must happen in order.

The second action can be:

A value (similar to Effect.as)
A function returning a value (similar to Effect.map)
A Promise
A function returning a Promise
An Effect
A function returning an Effect (similar to Effect.flatMap)

Example (Applying a Discount Based on Fetched Amount)

Let’s look at an example comparing Effect.andThen with Effect.map and Effect.flatMap:

1
import { pipe, Effect } from "effect"
2

3
// Function to apply a discount safely to a transaction amount
4
const applyDiscount = (total: number, discountRate: number): Effect.Effect<number, Error> =>
5
  discountRate === 0
6
    ? Effect.fail(new Error("Discount rate cannot be zero"))
7
    : Effect.succeed(total - (total * discountRate) / 100)
8

9
// Simulated asynchronous task to fetch a transaction amount from database
10
const fetchTransactionAmount = Effect.promise(() => Promise.resolve(100))
11

12
// Using Effect.map and Effect.flatMap
13
const result1 = pipe(
14
  fetchTransactionAmount,
15
  Effect.map((amount) => amount * 2),
16
  Effect.flatMap((amount) => applyDiscount(amount, 5)),
17
)
18

19
Effect.runPromise(result1).then(console.log) // Output: 190
20

21
// Using Effect.andThen
22
const result2 = pipe(
23
  fetchTransactionAmount,
24
  Effect.andThen((amount) => amount * 2),
25
  Effect.andThen((amount) => applyDiscount(amount, 5)),
26
)
27

28
Effect.runPromise(result2).then(console.log) // Output: 190

Option and Either with andThen

Both Option and Either are commonly used for handling optional or missing values or simple error cases. These types integrate well with Effect.andThen. When used with Effect.andThen, the operations are categorized as scenarios 5 and 6 (as discussed earlier) because both Option and Either are treated as effects in this context.

Example (with Option)

1
import { pipe, Effect, Option } from "effect"
2

3
// Simulated asynchronous task fetching a number from a database
4
const fetchNumberValue = Effect.tryPromise(() => Promise.resolve(42))
5

6
//      ┌─── Effect<number, UnknownException | NoSuchElementException, never>
7
//      ▼
8
const program = pipe(
9
  fetchNumberValue,
10
  Effect.andThen((x) => (x > 0 ? Option.some(x) : Option.none())),
11
)

You might expect the type of program to be Effect<Option<number>, UnknownException, never>, but it is actually Effect<number, UnknownException | NoSuchElementException, never>.

This is because Option<A> is treated as an effect of type Effect<A, NoSuchElementException>, and as a result, the possible errors are combined into a union type.

Example (with Either)

1
import { pipe, Effect, Either } from "effect"
2

3
// Function to parse an integer from a string that can fail
4
const parseInteger = (input: string): Either.Either<number, string> =>
5
  isNaN(parseInt(input)) ? Either.left("Invalid integer") : Either.right(parseInt(input))
6

7
// Simulated asynchronous task fetching a string from database
8
const fetchStringValue = Effect.tryPromise(() => Promise.resolve("42"))
9

10
//      ┌─── Effect<number, string | UnknownException, never>
11
//      ▼
12
const program = pipe(
13
  fetchStringValue,
14
  Effect.andThen((str) => parseInteger(str)),
15
)

Although one might expect the type of program to be Effect<Either<number, string>, UnknownException, never>, it is actually Effect<number, string | UnknownException, never>.

This is because Either<A, E> is treated as an effect of type Effect<A, E>, meaning the errors are combined into a union type.

tap

Runs a side effect with the result of an effect without changing the original value.

Use Effect.tap when you want to perform a side effect, like logging or tracking, without modifying the main value. This is useful when you need to observe or record an action but want the original value to be passed to the next step.

Effect.tap works similarly to Effect.flatMap, but it ignores the result of the function passed to it. The value from the previous effect remains available for the next part of the chain. Note that if the side effect fails, the entire chain will fail too.

Example (Logging a step in a pipeline)

1
import { pipe, Effect, Console } from "effect"
2

3
// Function to apply a discount safely to a transaction amount
4
const applyDiscount = (total: number, discountRate: number): Effect.Effect<number, Error> =>
5
  discountRate === 0
6
    ? Effect.fail(new Error("Discount rate cannot be zero"))
7
    : Effect.succeed(total - (total * discountRate) / 100)
8

9
// Simulated asynchronous task to fetch a transaction amount from database
10
const fetchTransactionAmount = Effect.promise(() => Promise.resolve(100))
11

12
const finalAmount = pipe(
13
  fetchTransactionAmount,
14
  // Log the fetched transaction amount
15
  Effect.tap((amount) => Console.log(`Apply a discount to: ${amount}`)),
16
  // `amount` is still available!
17
  Effect.flatMap((amount) => applyDiscount(amount, 5)),
18
)
19

20
Effect.runPromise(finalAmount).then(console.log)
21
/*
22
Output:
23
Apply a discount to: 100
24
95
25
*/

In this example, Effect.tap is used to log the transaction amount before applying the discount, without modifying the value itself. The original value (amount) remains available for the next operation (applyDiscount).

Using Effect.tap allows us to execute side effects during the computation without altering the result. This can be useful for logging, performing additional actions, or observing the intermediate values without interfering with the main computation flow.

all

Combines multiple effects into one, returning results based on the input structure.

Use Effect.all when you need to run multiple effects and combine their results into a single output. It supports tuples, iterables, structs, and records, making it flexible for different input types.

For instance, if the input is a tuple:

//         ┌─── a tuple of effects
//         ▼
Effect.all([effect1, effect2, ...])

the effects are executed in order, and the result is a new effect containing the results as a tuple. The results in the tuple match the order of the effects passed to Effect.all.

By default, Effect.all runs effects sequentially and produces a tuple or object with the results. If any effect fails, it stops execution (short-circuiting) and propagates the error.

See Collecting for more information on how to use Effect.all.

Example (Combining Configuration and Database Checks)

1
import { Effect } from "effect"
2

3
// Simulated function to read configuration from a file
4
const webConfig = Effect.promise(() => Promise.resolve({ dbConnection: "localhost", port: 8080 }))
5

6
// Simulated function to test database connectivity
7
const checkDatabaseConnectivity = Effect.promise(() => Promise.resolve("Connected to Database"))
8

9
// Combine both effects to perform startup checks
10
const startupChecks = Effect.all([webConfig, checkDatabaseConnectivity])
11

12
Effect.runPromise(startupChecks).then(([config, dbStatus]) => {
13
  console.log(`Configuration: ${JSON.stringify(config)}\nDB Status: ${dbStatus}`)
14
})
15
/*
16
Output:
17
Configuration: {"dbConnection":"localhost","port":8080}
18
DB Status: Connected to Database
19
*/

Build your first pipeline

Let’s now combine the pipe function, Effect.all, and Effect.andThen to create a pipeline that performs a sequence of transformations.

Example (Building a Transaction Pipeline)

1
import { Effect, pipe } from "effect"
2

3
// Function to add a small service charge to a transaction amount
4
const addServiceCharge = (amount: number) => amount + 1
5

6
// Function to apply a discount safely to a transaction amount
7
const applyDiscount = (total: number, discountRate: number): Effect.Effect<number, Error> =>
8
  discountRate === 0
9
    ? Effect.fail(new Error("Discount rate cannot be zero"))
10
    : Effect.succeed(total - (total * discountRate) / 100)
11

12
// Simulated asynchronous task to fetch a transaction amount from database
13
const fetchTransactionAmount = Effect.promise(() => Promise.resolve(100))
14

15
// Simulated asynchronous task to fetch a discount rate
16
// from a configuration file
17
const fetchDiscountRate = Effect.promise(() => Promise.resolve(5))
18

19
// Assembling the program using a pipeline of effects
20
const program = pipe(
21
  // Combine both fetch effects to get the transaction amount
22
  // and discount rate
23
  Effect.all([fetchTransactionAmount, fetchDiscountRate]),
24

25
  // Apply the discount to the transaction amount
26
  Effect.andThen(([transactionAmount, discountRate]) =>
27
    applyDiscount(transactionAmount, discountRate),
28
  ),
29

30
  // Add the service charge to the discounted amount
31
  Effect.andThen(addServiceCharge),
32

33
  // Format the final result for display
34
  Effect.andThen((finalAmount) => `Final amount to charge: ${finalAmount}`),
35
)
36

37
// Execute the program and log the result
38
Effect.runPromise(program).then(console.log)
39
// Output: "Final amount to charge: 96"

This pipeline demonstrates how you can structure your code by combining different effects into a clear, readable flow.

The pipe method

Effect provides a pipe method that works similarly to the pipe method found in rxjs. This method allows you to chain multiple operations together, making your code more concise and readable.

Syntax

const result = effect.pipe(func1, func2, ..., funcN)

This is equivalent to using the pipe function like this:

const result = pipe(effect, func1, func2, ..., funcN)

The pipe method is available on all effects and many other data types, eliminating the need to import the pipe function and saving you some keystrokes.

Example (Using the pipe Method)

Let’s rewrite an earlier example, this time using the pipe method.

1
import { Effect } from "effect"
2

13 collapsed lines
3
const addServiceCharge = (amount: number) => amount + 1
4

5
const applyDiscount = (total: number, discountRate: number): Effect.Effect<number, Error> =>
6
  discountRate === 0
7
    ? Effect.fail(new Error("Discount rate cannot be zero"))
8
    : Effect.succeed(total - (total * discountRate) / 100)
9

10
const fetchTransactionAmount = Effect.promise(() => Promise.resolve(100))
11

12
const fetchDiscountRate = Effect.promise(() => Promise.resolve(5))
13

14
const program = Effect.all([fetchTransactionAmount, fetchDiscountRate]).pipe(
15
  Effect.andThen(([transactionAmount, discountRate]) =>
16
    applyDiscount(transactionAmount, discountRate),
17
  ),
18
  Effect.andThen(addServiceCharge),
19
  Effect.andThen((finalAmount) => `Final amount to charge: ${finalAmount}`),
20
)

Cheatsheet

Let’s summarize the transformation functions we have seen so far:

API	Input	Output
`map`	`Effect<A, E, R>`, `A => B`	`Effect<B, E, R>`
`flatMap`	`Effect<A, E, R>`, `A => Effect<B, E, R>`	`Effect<B, E, R>`
`andThen`	`Effect<A, E, R>`, *	`Effect<B, E, R>`
`tap`	`Effect<A, E, R>`, `A => Effect<B, E, R>`	`Effect<A, E, R>`
`all`	`[Effect<A, E, R>, Effect<B, E, R>, ...]`	`Effect<[A, B, ...], E, R>`