Practical functional programming in Effect

1
import { 
import Array
Array } from 'effect';
2

3
import Array
Array.
const forEach: <number>(self: Iterable<number>, f: (a: number, i: number) => void) => void (+1 overload)
Performs a side-effect for each element of the Iterable.
Example
import { Array } from "effect"

Array.forEach([1, 2, 3], n => console.log(n)) // 1, 2, 3
@since ― 2.0.0
forEach(
4
  // explicit "state"
5
  [1, 2, 3],
6
  // callback
7
  
n: number
n => 
var console: Console
The console module provides a simple debugging console that is similar to the
JavaScript console mechanism provided by web browsers.
The module exports two specific components:

A Console class with methods such as console.log(), console.error() andconsole.warn() that can be used to write to any Node.js stream.
A global console instance configured to write to process.stdout and process.stderr. The global console can be used without callingrequire('console').

Warning: The global console object's methods are neither consistently
synchronous like the browser APIs they resemble, nor are they consistently
asynchronous like all other Node.js streams. See the note on process I/O for
more information.
Example using the global console:
console.log('hello world');
// Prints: hello world, to stdout
console.log('hello %s', 'world');
// Prints: hello world, to stdout
console.error(new Error('Whoops, something bad happened'));
// Prints error message and stack trace to stderr:
//   Error: Whoops, something bad happened
//     at [eval]:5:15
//     at Script.runInThisContext (node:vm:132:18)
//     at Object.runInThisContext (node:vm:309:38)
//     at node:internal/process/execution:77:19
//     at [eval]-wrapper:6:22
//     at evalScript (node:internal/process/execution:76:60)
//     at node:internal/main/eval_string:23:3

const name = 'Will Robinson';
console.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to stderr
Example using the Console class:
const out = getStreamSomehow();
const err = getStreamSomehow();
const myConsole = new console.Console(out, err);

myConsole.log('hello world');
// Prints: hello world, to out
myConsole.log('hello %s', 'world');
// Prints: hello world, to out
myConsole.error(new Error('Whoops, something bad happened'));
// Prints: [Error: Whoops, something bad happened], to err

const name = 'Will Robinson';
myConsole.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to err
@see ― source
console.
Console.log(message?: any, ...optionalParams: any[]): void
Prints to stdout with newline. Multiple arguments can be passed, with the
first used as the primary message and all additional used as substitution
values similar to printf(3) (the arguments are all passed to util.format()).
const count = 5;
console.log('count: %d', count);
// Prints: count: 5, to stdout
console.log('count:', count);
// Prints: count: 5, to stdout
See util.format() for more information.
@since ― v0.1.100
log(
n: number
n)
8
);

1
import { 
function pipe<A>(a: A): A (+19 overloads)
Pipes the value of an expression into a pipeline of functions.
Details
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.
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.
When to Use
This is useful in combination with data-last functions as a simulation of
methods:
as.map(f).filter(g)
becomes:
import { pipe, Array } from "effect"

pipe(as, Array.map(f), Array.filter(g))
Example (Chaining Arithmetic Operations)
import { pipe } from "effect"

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

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

console.log(result)
// Output: 2
@since ― 2.0.0
pipe } from 'effect'
2

24 collapsed lines
3
enum 
enum Currency
Currency {
4
  
function (enum member) Currency.Euro = 0
Euro,
5
  
function (enum member) Currency.Dollar = 1
Dollar,
6
}
7

8
interface 
interface Item
Item {
9
  
Item.description: string
description: string;
10
  
Item.quantity: number
quantity: number;
11
  
Item.price: number
price: number;
12
}
13

14
type 
type ShoppingCart = Item[]
ShoppingCart = 
interface Item
Item[];
15

16
interface 
interface UserPreferences
UserPreferences {
17
  
UserPreferences.currency: Currency
currency: 
enum Currency
Currency
18
}
19

20
declare const 
const calculateSubtotal: (shoppingCart: ShoppingCart) => number
calculateSubtotal: (
shoppingCart: ShoppingCart
shoppingCart: 
type ShoppingCart = Item[]
ShoppingCart) => number;
21
declare const 
const applyDiscount: (min: number, discount: number) => (input: number) => number
applyDiscount: (
min: number
min: number, 
discount: number
discount: number) => (
input: number
input: number) => number;
22
declare const 
const addTax: (tax: number) => (input: number) => number
addTax: (
tax: number
tax: number) => (
input: number
input: number) => number;
23
declare const 
const formatCurrency: (userPreferences: UserPreferences) => (input: number) => string
formatCurrency: (
userPreferences: UserPreferences
userPreferences: 
interface UserPreferences
UserPreferences) => (
input: number
input: number) => string;
24

25
declare const 
const userPreferences: UserPreferences
userPreferences: 
interface UserPreferences
UserPreferences;
26
declare const 
const shoppingCart: ShoppingCart
shoppingCart: 
type ShoppingCart = Item[]
ShoppingCart;
27

28
const 
const invoice: string
invoice = 
pipe<ShoppingCart, number, number, number, string>(a: ShoppingCart, ab: (a: ShoppingCart) => number, bc: (b: number) => number, cd: (c: number) => number, de: (d: number) => string): string (+19 overloads)
Pipes the value of an expression into a pipeline of functions.
Details
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.
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.
When to Use
This is useful in combination with data-last functions as a simulation of
methods:
as.map(f).filter(g)
becomes:
import { pipe, Array } from "effect"

pipe(as, Array.map(f), Array.filter(g))
Example (Chaining Arithmetic Operations)
import { pipe } from "effect"

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

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

console.log(result)
// Output: 2
@since ― 2.0.0
pipe(
29
  // The value we start with.
30
  
const shoppingCart: ShoppingCart
shoppingCart,
31
  // A function that takes the shopping cart and sums the amounts of the line
32
  // items.
33
  
const calculateSubtotal: (shoppingCart: ShoppingCart) => number
calculateSubtotal, // 100
34
  // Returns a function that will take the result from the previous step
35
  // (`calculateSubtotal`) and apply a discount of 0.10 if the subtotal is >
36
  // 10,000 cents.
37
  
const applyDiscount: (min: number, discount: number) => (input: number) => number
applyDiscount(10, 0.10), // 90
38
  // Returns a function that will take the result from the previous step (having
39
  // applied the discount), and apply an 8% tax.
40
  
const addTax: (tax: number) => (input: number) => number
addTax(0.08), // 97.2
41
  // Returns a function that will take the result from the previous step (having
42
  // applied the tax), and formats it to the preferred currency.
43
  
const formatCurrency: (userPreferences: UserPreferences) => (input: number) => string
formatCurrency(
const userPreferences: UserPreferences
userPreferences) // "97.20 €"
44
);
45

46
var console: Console
The console module provides a simple debugging console that is similar to the
JavaScript console mechanism provided by web browsers.
The module exports two specific components:

A Console class with methods such as console.log(), console.error() andconsole.warn() that can be used to write to any Node.js stream.
A global console instance configured to write to process.stdout and process.stderr. The global console can be used without callingrequire('console').

Warning: The global console object's methods are neither consistently
synchronous like the browser APIs they resemble, nor are they consistently
asynchronous like all other Node.js streams. See the note on process I/O for
more information.
Example using the global console:
console.log('hello world');
// Prints: hello world, to stdout
console.log('hello %s', 'world');
// Prints: hello world, to stdout
console.error(new Error('Whoops, something bad happened'));
// Prints error message and stack trace to stderr:
//   Error: Whoops, something bad happened
//     at [eval]:5:15
//     at Script.runInThisContext (node:vm:132:18)
//     at Object.runInThisContext (node:vm:309:38)
//     at node:internal/process/execution:77:19
//     at [eval]-wrapper:6:22
//     at evalScript (node:internal/process/execution:76:60)
//     at node:internal/main/eval_string:23:3

const name = 'Will Robinson';
console.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to stderr
Example using the Console class:
const out = getStreamSomehow();
const err = getStreamSomehow();
const myConsole = new console.Console(out, err);

myConsole.log('hello world');
// Prints: hello world, to out
myConsole.log('hello %s', 'world');
// Prints: hello world, to out
myConsole.error(new Error('Whoops, something bad happened'));
// Prints: [Error: Whoops, something bad happened], to err

const name = 'Will Robinson';
myConsole.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to err
@see ― source
console.
Console.log(message?: any, ...optionalParams: any[]): void
Prints to stdout with newline. Multiple arguments can be passed, with the
first used as the primary message and all additional used as substitution
values similar to printf(3) (the arguments are all passed to util.format()).
const count = 5;
console.log('count: %d', count);
// Prints: count: 5, to stdout
console.log('count:', count);
// Prints: count: 5, to stdout
See util.format() for more information.
@since ― v0.1.100
log(
const invoice: string
invoice) // "97.20 €"

1
import { 
import Data
Data, 
import Effect
@since ― 2.0.0
@since ― 2.0.0
@since ― 2.0.0
Effect, 
function pipe<A>(a: A): A (+19 overloads)
Pipes the value of an expression into a pipeline of functions.
Details
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.
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.
When to Use
This is useful in combination with data-last functions as a simulation of
methods:
as.map(f).filter(g)
becomes:
import { pipe, Array } from "effect"

pipe(as, Array.map(f), Array.filter(g))
Example (Chaining Arithmetic Operations)
import { pipe } from "effect"

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

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

console.log(result)
// Output: 2
@since ― 2.0.0
pipe, 
import Schema
Schema } from "effect"
2

20 collapsed lines
3
interface 
interface Request
Request {
4
  
Request.data: string
data: string
5
}
6

7
const 
const CreateAccountSchema: Schema.Struct<{
    name: typeof Schema.String;
}>
CreateAccountSchema = 
import Schema
Schema.
function Struct<{
    name: typeof Schema.String;
}>(fields: {
    name: typeof Schema.String;
}): Schema.Struct<{
    name: typeof Schema.String;
}> (+1 overload)
@since ― 3.10.0
Struct({
8
  
name: typeof Schema.String
name: 
import Schema
Schema.
class String
export String
@since ― 3.10.0
String
9
})
10

11
const 
const AccountSchema: Schema.Struct<{
    id: typeof Schema.UUID;
    name: typeof Schema.String;
}>
AccountSchema = 
import Schema
Schema.
function Struct<{
    id: typeof Schema.UUID;
    name: typeof Schema.String;
}>(fields: {
    id: typeof Schema.UUID;
    name: typeof Schema.String;
}): Schema.Struct<{
    id: typeof Schema.UUID;
    name: typeof Schema.String;
}> (+1 overload)
@since ― 3.10.0
Struct({
12
  
id: typeof Schema.UUID
id: 
import Schema
Schema.
class UUID
Represents a Universally Unique Identifier (UUID).
This schema ensures that the provided string adheres to the standard UUID format.
@since ― 3.10.0
UUID,
13
  
name: typeof Schema.String
name: 
import Schema
Schema.
class String
export String
@since ― 3.10.0
String
14
})
15

16
class 
class AccountCreateError
AccountCreateError extends 
import Data
Data.
const TaggedError: <"AccountCreateError">(tag: "AccountCreateError") => new <A>(args: Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => YieldableError & {
    readonly _tag: "AccountCreateError";
} & Readonly<A>
@since ― 2.0.0
TaggedError("AccountCreateError") {}
17
class 
class HttpError
HttpError extends 
import Data
Data.
const TaggedError: <"HttpError">(tag: "HttpError") => new <A>(args: Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => YieldableError & {
    readonly _tag: "HttpError";
} & Readonly<A>
@since ― 2.0.0
TaggedError("HttpError") {}
18
declare const 
const toHttpError: <E>(e: E) => HttpError
toHttpError: <
function (type parameter) E in <E>(e: E): HttpError
E>(
e: E
e: 
function (type parameter) E in <E>(e: E): HttpError
E) => 
class HttpError
HttpError
19

20
declare const 
const createAccount: (createAccountInput: typeof CreateAccountSchema.Type) => Effect.Effect<typeof AccountSchema.Type, AccountCreateError>
createAccount: (
21
  
createAccountInput: {
    readonly name: string;
}
createAccountInput: typeof 
const CreateAccountSchema: Schema.Struct<{
    name: typeof Schema.String;
}>
CreateAccountSchema.
Schema<{ readonly name: string; }, { readonly name: string; }, never>.Type: {
    readonly name: string;
}
Type
22
) => 
import Effect
@since ― 2.0.0
@since ― 2.0.0
@since ― 2.0.0
Effect.
interface Effect<out A, out E = never, out R = never>
The Effect interface defines a value that describes a workflow or job,
which can succeed or fail.
Details
The Effect interface represents a computation that can model a workflow
involving various types of operations, such as synchronous, asynchronous,
concurrent, and parallel interactions. It operates within a context of type
R, and the result can either be a success with a value of type A or a
failure with an error of type E. The Effect is designed to handle complex
interactions with external resources, offering advanced features such as
fiber-based concurrency, scheduling, interruption handling, and scalability.
This makes it suitable for tasks that require fine-grained control over
concurrency and error management.
To execute an Effect value, you need a Runtime, which provides the
environment necessary to run and manage the computation.
@since ― 2.0.0
@since ― 2.0.0
Effect<typeof 
const AccountSchema: Schema.Struct<{
    id: typeof Schema.UUID;
    name: typeof Schema.String;
}>
AccountSchema.
Schema<{ readonly name: string; readonly id: string; }, { readonly name: string; readonly id: string; }, never>.Type: {
    readonly name: string;
    readonly id: string;
}
Type, 
class AccountCreateError
AccountCreateError>
23

24
const 
const handleRequest: (request: Request) => Effect.Effect<{
    readonly name: string;
    readonly id: string;
}, HttpError, never>
handleRequest = (
request: Request
request: 
interface Request
Request) =>
25
  
pipe<string, Effect.Effect<{
    readonly name: string;
}, ParseError, never>, Effect.Effect<{
    readonly name: string;
    readonly id: string;
}, AccountCreateError | ParseError, never>, Effect.Effect<{
    readonly name: string;
    readonly id: string;
}, HttpError, never>>(a: string, ab: (a: string) => Effect.Effect<{
    readonly name: string;
}, ParseError, never>, bc: (b: Effect.Effect<{
    readonly name: string;
}, ParseError, never>) => Effect.Effect<{
    readonly name: string;
    readonly id: string;
}, AccountCreateError | ParseError, never>, cd: (c: Effect.Effect<...>) => Effect.Effect<...>): Effect.Effect<...> (+19 overloads)
Pipes the value of an expression into a pipeline of functions.
Details
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.
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.
When to Use
This is useful in combination with data-last functions as a simulation of
methods:
as.map(f).filter(g)
becomes:
import { pipe, Array } from "effect"

pipe(as, Array.map(f), Array.filter(g))
Example (Chaining Arithmetic Operations)
import { pipe } from "effect"

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

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

console.log(result)
// Output: 2
@since ― 2.0.0
pipe(
26
    // raw data from a network request
27
    
request: Request
request.
Request.data: string
data,
28
    // validate and convert to internal representation
29
    
import Schema
Schema.
const parseJson: <Schema.Struct<{
    name: typeof Schema.String;
}>>(schema: Schema.Struct<{
    name: typeof Schema.String;
}>, options?: Schema.ParseJsonOptions) => Schema.transform<Schema.SchemaClass<unknown, string, never>, Schema.Struct<{
    name: typeof Schema.String;
}>> (+1 overload)
The ParseJson combinator provides a method to convert JSON strings into the unknown type using the underlying
functionality of JSON.parse. It also utilizes JSON.stringify for encoding.
You can optionally provide a ParseJsonOptions to configure both JSON.parse and JSON.stringify executions.
Optionally, you can pass a schema Schema<A, I, R> to obtain an A type instead of unknown.
@example 
import * as assert from "node:assert"
import * as Schema from "effect/Schema"

assert.deepStrictEqual(Schema.decodeUnknownSync(Schema.parseJson())(`{"a":"1"}`), { a: "1" })
assert.deepStrictEqual(Schema.decodeUnknownSync(Schema.parseJson(Schema.Struct({ a: Schema.NumberFromString })))(`{"a":"1"}`), { a: 1 })
@since ― 3.10.0
parseJson(
const CreateAccountSchema: Schema.Struct<{
    name: typeof Schema.String;
}>
CreateAccountSchema).
Pipeable.pipe<Schema.transform<Schema.SchemaClass<unknown, string, never>, Schema.Struct<{
    name: typeof Schema.String;
}>>, (i: string, overrideOptions?: ParseOptions) => Effect.Effect<{
    readonly name: string;
}, ParseError, never>>(this: Schema.transform<...>, ab: (_: Schema.transform<Schema.SchemaClass<unknown, string, never>, Schema.Struct<{
    name: typeof Schema.String;
}>>) => (i: string, overrideOptions?: ParseOptions) => Effect.Effect<{
    readonly name: string;
}, ParseError, never>): (i: string, overrideOptions?: ParseOptions) => Effect.Effect<{
    readonly name: string;
}, ParseError, never> (+21 overloads)
pipe(
import Schema
Schema.
const decode: <A, I, R>(schema: Schema.Schema<A, I, R>, options?: ParseOptions) => (i: I, overrideOptions?: ParseOptions) => Effect.Effect<A, ParseError, R>
@since ― 3.10.0
decode),
30
    // actually create the account
31
    
import Effect
@since ― 2.0.0
@since ― 2.0.0
@since ― 2.0.0
Effect.
const andThen: <{
    readonly name: string;
}, Effect.Effect<{
    readonly name: string;
    readonly id: string;
}, AccountCreateError, never>>(f: (a: {
    readonly name: string;
}) => Effect.Effect<{
    readonly name: string;
    readonly id: string;
}, AccountCreateError, never>) => <E, R>(self: Effect.Effect<{
    readonly name: string;
}, E, R>) => Effect.Effect<{
    readonly name: string;
    readonly id: string;
}, AccountCreateError | E, R> (+3 overloads)
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))
When to Use
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.
Details
The second action can be:

A constant value (similar to

as
)

A function returning a value (similar to

map
)

A Promise
A function returning a Promise
An Effect
A function returning an Effect (similar to

flatMap
)
Note: andThen works well with both Option and Either types,
treating them as effects.
Example (Applying a Discount Based on Fetched Amount)
import { pipe, Effect } from "effect"

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

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

// Using Effect.map and Effect.flatMap
const result1 = pipe(
  fetchTransactionAmount,
  Effect.map((amount) => amount * 2),
  Effect.flatMap((amount) => applyDiscount(amount, 5))
)

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

// Using Effect.andThen
const result2 = pipe(
  fetchTransactionAmount,
  Effect.andThen((amount) => amount * 2),
  Effect.andThen((amount) => applyDiscount(amount, 5))
)

Effect.runPromise(result2).then(console.log)
// Output: 190
@since ― 2.0.0
andThen(
const createAccount: (createAccountInput: typeof CreateAccountSchema.Type) => Effect.Effect<typeof AccountSchema.Type, AccountCreateError>
createAccount),
32
    // map possible errors to errors that make sense as an http response
33
    
import Effect
@since ― 2.0.0
@since ― 2.0.0
@since ― 2.0.0
Effect.
const mapError: <AccountCreateError | ParseError, HttpError>(f: (e: AccountCreateError | ParseError) => HttpError) => <A, R>(self: Effect.Effect<A, AccountCreateError | ParseError, R>) => Effect.Effect<A, HttpError, R> (+1 overload)
Transforms or modifies the error produced by an effect without affecting its
success value.
When to Use
This function is helpful when you want to enhance the error with additional
information, change the error type, or apply custom error handling while
keeping the original behavior of the effect's success values intact. It only
operates on the error channel and leaves the success channel unchanged.
Example
import { Effect } from "effect"

//      ┌─── Effect<number, string, never>
//      ▼
const simulatedTask = Effect.fail("Oh no!").pipe(Effect.as(1))

//      ┌─── Effect<number, Error, never>
//      ▼
const mapped = Effect.mapError(
  simulatedTask,
  (message) => new Error(message)
)
@see ― map for a version that operates on the success channel.
@see ― mapBoth for a version that operates on both channels.
@see ― orElseFail if you want to replace the error with a new one.
@since ― 2.0.0
mapError(
const toHttpError: <E>(e: E) => HttpError
toHttpError)
34
  )

1
import { 
function pipe<A>(a: A): A (+19 overloads)
Pipes the value of an expression into a pipeline of functions.
Details
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.
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.
When to Use
This is useful in combination with data-last functions as a simulation of
methods:
as.map(f).filter(g)
becomes:
import { pipe, Array } from "effect"

pipe(as, Array.map(f), Array.filter(g))
Example (Chaining Arithmetic Operations)
import { pipe } from "effect"

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

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

console.log(result)
// Output: 2
@since ― 2.0.0
pipe } from 'effect'
2

3
const 
const divide: (n1: number, n2: number) => number
divide = (
n1: number
n1: number, 
n2: number
n2: number) => 
n1: number
n1/
n2: number
n2;
4
pipe<number, never>(a: number, ab: (a: number) => never): never (+19 overloads)
Pipes the value of an expression into a pipeline of functions.
Details
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.
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.
When to Use
This is useful in combination with data-last functions as a simulation of
methods:
as.map(f).filter(g)
becomes:
import { pipe, Array } from "effect"

pipe(as, Array.map(f), Array.filter(g))
Example (Chaining Arithmetic Operations)
import { pipe } from "effect"

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

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

console.log(result)
// Output: 2
@since ― 2.0.0
pipe(1, divide(2))
Error ts(2554)  ― Expected 2 arguments, but got 1.
Error ts(2345)  ― Argument of type 'number' is not assignable to parameter of type '(a: number) => never'.
5

1
const 
const curriedDivide: (n2: number) => (n1: number) => number
curriedDivide = (
n2: number
n2: number) => (
n1: number
n1: number) => 
n1: number
n1/
n2: number
n2;

1
type 
type ArrayMap = <I, O>(container: Array<I>, operation: (inner: I) => O) => Array<O>
ArrayMap = <
function (type parameter) I in <I, O>(container: Array<I>, operation: (inner: I) => O): Array<O>
I, 
function (type parameter) O in <I, O>(container: Array<I>, operation: (inner: I) => O): Array<O>
O>(
container: I[]
container: 
interface Array<T>
Array<
function (type parameter) I in <I, O>(container: Array<I>, operation: (inner: I) => O): Array<O>
I>, 
operation: (inner: I) => O
operation: (
inner: I
inner: 
function (type parameter) I in <I, O>(container: Array<I>, operation: (inner: I) => O): Array<O>
I) => 
function (type parameter) O in <I, O>(container: Array<I>, operation: (inner: I) => O): Array<O>
O) => 
interface Array<T>
Array<
function (type parameter) O in <I, O>(container: Array<I>, operation: (inner: I) => O): Array<O>
O>