(input: {
readonly resourceKey: string
readonly prefer: string
}): Effect.Effect<string, never, Advice>Publish placement advice (requires Advice in context).
yield* Lookup.advise({ resourceKey: Worker.key, prefer: "fleet/Worker#w2" })export const const advise: (input: {
readonly resourceKey: string
readonly prefer: string
}) => Effect.Effect<string, never, Advice>
Publish placement advice (requires
Advice
in context).
yield* Lookup.advise({ resourceKey: Worker.key, prefer: "fleet/Worker#w2" })
advise = (input: {
readonly resourceKey: string
readonly prefer: string
}
resourceKey: stringresourceKey: string;
readonly prefer: stringprefer: string;
}): import EffectEffect.interface Effect<out A, out E = never, out R = never>The Effect interface defines a value that lazily describes a workflow or
job. The workflow requires some context R, and may fail with an error of
type E, or succeed with a value of type A.
When to use
Use when you need to represent a lazy, composable workflow that can require
services, fail with a typed error, or succeed with a typed value.
Details
Effect values model resourceful interaction with the outside world,
including synchronous, asynchronous, concurrent, and parallel interaction.
They use a fiber-based concurrency model, with built-in support for
scheduling, fine-grained interruption, structured concurrency, and high
scalability.
To run an Effect value, you need a Runtime, which is a type that is
capable of executing Effect values.
Effect<string, never, class AdviceLookup placement board — coordinator advice for nodeless /
Hyperlink.lookupClient
dial.
v1: last-write-wins, in-memory, no advisor ACL. Algorithms stay app-owned (who calls
advise
); Lookup only stores and surfaces the preference.
Advice> =>
import EffectEffect.const flatMap: <unknown, never, Advice, string, never, Advice>(self: Effect.Effect<unknown, never, Advice>, f: (a: unknown) => Effect.Effect<string, never, Advice>) => Effect.Effect<string, never, Advice> (+1 overload)Chains effects to produce new Effect instances, useful for combining
operations that depend on previous results.
When to use
Use when you need to chain multiple effects, ensuring that each
step produces a new Effect while flattening any nested effects that may
occur.
Details
flatMap lets you sequence effects so that the result of one effect can be
used in the next step. It is similar to flatMap used with arrays but works
specifically with Effect instances, allowing you to avoid deeply nested
effect structures.
Since effects are immutable, flatMap always returns a new effect instead of
changing the original one.
Example (Choosing flatMap syntax variants)
import { Effect, pipe } from "effect"
const myEffect = Effect.succeed(1)
const transformation = (n: number) => Effect.succeed(n + 1)
const flatMappedWithPipe = pipe(myEffect, Effect.flatMap(transformation))
const flatMappedWithDataFirst = Effect.flatMap(myEffect, transformation)
const flatMappedWithMethod = myEffect.pipe(Effect.flatMap(transformation))
Example (Sequencing dependent effects)
import { Data, Effect, pipe } from "effect"
class DiscountRateError extends Data.TaggedError("DiscountRateError")<{}> {}
// Function to apply a discount safely to a transaction amount
const applyDiscount = (
total: number,
discountRate: number
): Effect.Effect<number, DiscountRateError> =>
discountRate === 0
? Effect.fail(new DiscountRateError())
: Effect.succeed(total - (total * discountRate) / 100)
// Simulated asynchronous task to fetch a transaction amount from database
const fetchTransactionAmount = Effect.promise(() => Promise.resolve(100))
// Chaining the fetch and discount application using `flatMap`
const finalAmount = pipe(
fetchTransactionAmount,
Effect.flatMap((amount) => applyDiscount(amount, 5))
)
Effect.runPromise(finalAmount).then(console.log)
// Output: 95
flatMap(class AdviceLookup placement board — coordinator advice for nodeless /
Hyperlink.lookupClient
dial.
v1: last-write-wins, in-memory, no advisor ACL. Algorithms stay app-owned (who calls
advise
); Lookup only stores and surfaces the preference.
Advice, (svc: unknownsvc) =>
svc: unknownsvc.advise(
new constructor AdviseRequest(props: Schema.Struct<Fields extends Schema.Struct.Fields>.ReadonlyMakeIn<{
readonly resourceKey: Schema.String;
readonly prefer: Schema.String;
}>, options?: Schema.MakeOptions | undefined): AdviseRequest
constructor AdviseRequest(props: Schema.Struct<Fields extends Schema.Struct.Fields>.ReadonlyMakeIn<{
readonly resourceKey: Schema.String;
readonly prefer: Schema.String;
}>, options?: Schema.MakeOptions | undefined): {
Type: Self;
Encoded: S["Encoded"];
DecodingServices: S["DecodingServices"];
EncodingServices: S["EncodingServices"];
Iso: S["Iso"];
identifier: string;
fields: S["fields"];
mapFields: (f: (fields: { readonly resourceKey: Schema.String; readonly prefer: Schema.String }) => To, options?: { readonly unsafePreserveChecks?: boolean | undefined } | undefined) => Schema.Struct<{ [K in keyof Readonly<To>]: Readonly<To>[K]; }>;
extend: (identifier: string) => { (fields: NewFields, annotations?: Schema.Annotations.Declaration<Extended, readonly [Schema.Struct<{ [K in keyof { [K in keyof (('resourceKey' | 'prefer') & keyof NewFields extends never ? { readonly resourceKey: …;
Rebuild: Rebuild;
ast: Ast;
annotate: (annotations: Schema.Annotations.Bottom<AdviseRequest, readonly [Schema.Struct<{ readonly resourceKey: Schema.String; readonly prefer: Schema.String }>]>) => Schema.decodeTo<Schema.declareConstructor<AdviseRequest, Schema.Struct.ReadonlySi…;
annotateKey: (annotations: Schema.Annotations.Key<AdviseRequest>) => Schema.decodeTo<Schema.declareConstructor<AdviseRequest, Schema.Struct.ReadonlySide<{ readonly resourceKey: Schema.String; readonly prefer: Schema.String }, 'Encoded'>, readonly [Sche…;
check: (checks_0: Check<AdviseRequest>, ...checks: Array<Check<AdviseRequest>>) => Schema.decodeTo<Schema.declareConstructor<AdviseRequest, Schema.Struct.ReadonlySide<{ readonly resourceKey: Schema.String; readonly prefer: Schema.String }, 'Encod…;
rebuild: (ast: Declaration) => Schema.decodeTo<Schema.declareConstructor<AdviseRequest, Schema.Struct.ReadonlySide<{ readonly resourceKey: Schema.String; readonly prefer: Schema.String }, 'Encoded'>, readonly [Schema.Struct<{ readonly resourceKey: …;
make: (input: Schema.Struct.ReadonlyMakeIn<{ readonly resourceKey: Schema.String; readonly prefer: Schema.String }>, options?: Schema.MakeOptions) => AdviseRequest;
makeOption: (input: Schema.Struct.ReadonlyMakeIn<{ readonly resourceKey: Schema.String; readonly prefer: Schema.String }>, options?: Schema.MakeOptions) => Option.Option<AdviseRequest>;
makeEffect: (input: Schema.Struct.ReadonlyMakeIn<{ readonly resourceKey: Schema.String; readonly prefer: Schema.String }>, options?: Schema.MakeOptions) => Effect.Effect<AdviseRequest, Schema.SchemaError, never>;
pipe: { <A>(this: A): A; <A, B = never>(this: A, ab: (_: A) => B): B; <A, B = never, C = never>(this: A, ab: (_: A) => B, bc: (_: B) => C): C; <A, B = never, C = never, D = never>(this: A, ab: (_: A) => B, bc: (_: B) => C, cd: (_: C) => D): D; <…;
}
Placement advice — prefer this directory nodeKey when dialing resourceKey.
AdviseRequest({
resourceKey: stringresourceKey: input: {
readonly resourceKey: string
readonly prefer: string
}
resourceKey: stringresourceKey,
prefer: stringDirectory row nodeKey to prefer (e.g. fleet/Worker#w2).
prefer: input: {
readonly resourceKey: string
readonly prefer: string
}
prefer: stringprefer,
}),
),
);