(input: {
readonly serviceKey: string
readonly prefer: string
}): Effect.Effect<string, never, Advice>Publish placement advice (requires Advice in context).
yield* Lookup.advise({ serviceKey: Worker.key, prefer: "fleet/Worker#w2" })export const const advise: (input: {
readonly serviceKey: string
readonly prefer: string
}) => Effect.Effect<string, never, Advice>
Publish placement advice (requires
Advice
in context).
yield* Lookup.advise({ serviceKey: Worker.key, prefer: "fleet/Worker#w2" })
advise = (input: {
readonly serviceKey: string
readonly prefer: string
}
serviceKey: stringserviceKey: 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 Adviceclass Advice {
key: Identifier;
Service: {
advise: (payload: { serviceKey: string; prefer: string }) => Effect.Effect<string, never, never>;
clear: (payload: { serviceKey: string }) => Effect.Effect<boolean, never, never>;
preferred: (payload: { serviceKey: string }) => Effect.Effect<Option.Option<string>, never, never>;
};
}
Lookup 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: {
<A, B, E1, R1>(
f: (a: A) => Effect<B, E1, R1>
): <E, R>(
self: Effect<A, E, R>
) => Effect<B, E1 | E, R1 | R>
<A, E, R, B, E1, R1>(
self: Effect<A, E, R>,
f: (a: A) => Effect<B, E1, R1>
): Effect<B, E | E1, R | R1>
}
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 Adviceclass Advice {
key: Identifier;
Service: {
advise: (payload: { serviceKey: string; prefer: string }) => Effect.Effect<string, never, never>;
clear: (payload: { serviceKey: string }) => Effect.Effect<boolean, never, never>;
preferred: (payload: { serviceKey: string }) => Effect.Effect<Option.Option<string>, never, never>;
};
description: string | undefined;
of: (this: void, self: { readonly advise: (payload: { serviceKey: string; prefer: string }) => Effect.Effect<string, never, never>; readonly clear: (payload: { serviceKey: string }) => Effect.Effect<boolean, never, never>; readonly preferred: …;
context: (self: { readonly advise: (payload: { serviceKey: string; prefer: string }) => Effect.Effect<string, never, never>; readonly clear: (payload: { serviceKey: string }) => Effect.Effect<boolean, never, never>; readonly preferred: (payload: { …;
use: (f: (service: { readonly advise: (payload: { serviceKey: string; prefer: string }) => Effect.Effect<string, never, never>; readonly clear: (payload: { serviceKey: string }) => Effect.Effect<boolean, never, never>; readonly preferred: (payl…;
useSync: (f: (service: { readonly advise: (payload: { serviceKey: string; prefer: string }) => Effect.Effect<string, never, never>; readonly clear: (payload: { serviceKey: string }) => Effect.Effect<boolean, never, never>; readonly preferred: (payl…;
Identifier: Identifier;
stack: string | undefined;
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; <…;
toString: () => string;
toJSON: () => unknown;
}
Lookup 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: {
readonly advise: (payload: {
serviceKey: string
prefer: string
}) => Effect.Effect<string, never, never>
readonly clear: (payload: {
serviceKey: string
}) => Effect.Effect<boolean, never, never>
readonly preferred: (payload: {
serviceKey: string
}) => Effect.Effect<
Option.Option<string>,
never,
never
>
}
svc: {
readonly advise: (payload: {
serviceKey: string
prefer: string
}) => Effect.Effect<string, never, never>
readonly clear: (payload: {
serviceKey: string
}) => Effect.Effect<boolean, never, never>
readonly preferred: (payload: {
serviceKey: string
}) => Effect.Effect<
Option.Option<string>,
never,
never
>
}
advise: (payload: {
serviceKey: string
prefer: string
}) => Effect.Effect<string, never, never>
constructor AdviseRequest(props: Schema.Struct<Fields extends Schema.Struct.Fields>.ReadonlyMakeIn<{
readonly serviceKey: Schema.String;
readonly prefer: Schema.String;
}>, options?: Schema.MakeOptions | undefined): AdviseRequest
constructor AdviseRequest(props: Schema.Struct<Fields extends Schema.Struct.Fields>.ReadonlyMakeIn<{
readonly serviceKey: 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 serviceKey: 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 (('serviceKey' | 'prefer') & keyof NewFields extends never ? { readonly serviceKey: Sc…;
Rebuild: Rebuild;
ast: Ast;
annotate: (annotations: Schema.Annotations.Bottom<AdviseRequest, readonly [Schema.Struct<{ readonly serviceKey: Schema.String; readonly prefer: Schema.String }>]>) => Schema.decodeTo<Schema.declareConstructor<AdviseRequest, Schema.Struct.ReadonlySid…;
annotateKey: (annotations: Schema.Annotations.Key<AdviseRequest>) => Schema.decodeTo<Schema.declareConstructor<AdviseRequest, Schema.Struct.ReadonlySide<{ readonly serviceKey: Schema.String; readonly prefer: Schema.String }, 'Encoded'>, readonly [Schem…;
check: (checks_0: Check<AdviseRequest>, ...checks: Array<Check<AdviseRequest>>) => Schema.decodeTo<Schema.declareConstructor<AdviseRequest, Schema.Struct.ReadonlySide<{ readonly serviceKey: Schema.String; readonly prefer: Schema.String }, 'Encode…;
rebuild: (ast: Declaration) => Schema.decodeTo<Schema.declareConstructor<AdviseRequest, Schema.Struct.ReadonlySide<{ readonly serviceKey: Schema.String; readonly prefer: Schema.String }, 'Encoded'>, readonly [Schema.Struct<{ readonly serviceKey: Sc…;
make: (input: Struct.ReadonlyMakeIn<{ readonly serviceKey: String; readonly prefer: String }>, options?: MakeOptions) => AdviseRequest;
makeOption: (input: Struct.ReadonlyMakeIn<{ readonly serviceKey: String; readonly prefer: String }>, options?: MakeOptions) => Option_.Option<AdviseRequest>;
makeEffect: (input: Struct.ReadonlyMakeIn<{ readonly serviceKey: String; readonly prefer: String }>, options?: MakeOptions) => Effect.Effect<AdviseRequest, 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 serviceKey.
AdviseRequest({
serviceKey: stringserviceKey: input: {
readonly serviceKey: string
readonly prefer: string
}
serviceKey: stringserviceKey,
prefer: stringDirectory row nodeKey to prefer (e.g. fleet/Worker#w2).
prefer: input: {
readonly serviceKey: string
readonly prefer: string
}
prefer: stringprefer,
}),
),
);