Read preferred directory nodeKey for a HyperService (Tag or wire key).
export const const preferred: (
service: string | { readonly key: string }
) => Effect.Effect<
Option.Option<string>,
never,
Advice
>
Read preferred directory nodeKey for a HyperService (Tag or wire key).
preferred = (
service: | string
| {
readonly key: string
}
key: stringkey: 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<import OptionOption.type Option<A> = Option.None<A> | Option.Some<A>The Option data type represents optional values. An Option<A> is either
Some<A>, containing a value of type A, or None, representing absence.
When to use
Use to represent initial values that may not yet exist
- Returning from partial functions (not defined for all inputs)
- Managing optional fields in data structures
Namespace containing utility types for Option.
When to use
Use to access type-level helpers associated with Option.
Option<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
>
}
preferred: (payload: {
serviceKey: string
}) => Effect.Effect<
Option.Option<string>,
never,
never
>
constructor PreferredRequest(props: Schema.Struct<Fields extends Schema.Struct.Fields>.ReadonlyMakeIn<{
readonly serviceKey: Schema.String;
}>, options?: Schema.MakeOptions | undefined): PreferredRequest
constructor PreferredRequest(props: Schema.Struct<Fields extends Schema.Struct.Fields>.ReadonlyMakeIn<{
readonly serviceKey: 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 }) => 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' & keyof NewFields extends never ? { readonly serviceKey: Schema.String; …;
Rebuild: Rebuild;
ast: Ast;
annotate: (annotations: Schema.Annotations.Bottom<PreferredRequest, readonly [Schema.Struct<{ readonly serviceKey: Schema.String }>]>) => Schema.decodeTo<Schema.declareConstructor<PreferredRequest, Schema.Struct.ReadonlySide<{ readonly serviceKey: S…;
annotateKey: (annotations: Schema.Annotations.Key<PreferredRequest>) => Schema.decodeTo<Schema.declareConstructor<PreferredRequest, Schema.Struct.ReadonlySide<{ readonly serviceKey: Schema.String }, 'Encoded'>, readonly [Schema.Struct<{ readonly servic…;
check: (checks_0: Check<PreferredRequest>, ...checks: Array<Check<PreferredRequest>>) => Schema.decodeTo<Schema.declareConstructor<PreferredRequest, Schema.Struct.ReadonlySide<{ readonly serviceKey: Schema.String }, 'Encoded'>, readonly [Schema.S…;
rebuild: (ast: Declaration) => Schema.decodeTo<Schema.declareConstructor<PreferredRequest, Schema.Struct.ReadonlySide<{ readonly serviceKey: Schema.String }, 'Encoded'>, readonly [Schema.Struct<{ readonly serviceKey: Schema.String }>], Schema.Struc…;
make: (input: Struct.ReadonlyMakeIn<{ readonly serviceKey: String }>, options?: MakeOptions) => PreferredRequest;
makeOption: (input: Struct.ReadonlyMakeIn<{ readonly serviceKey: String }>, options?: MakeOptions) => Option_.Option<PreferredRequest>;
makeEffect: (input: Struct.ReadonlyMakeIn<{ readonly serviceKey: String }>, options?: MakeOptions) => Effect.Effect<PreferredRequest, 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; <…;
}
Read the preferred directory nodeKey for a HyperService (if any).
PreferredRequest({ serviceKey: stringserviceKey: const serviceKeyOf: (
service:
| string
| {
readonly key: string
}
) => string
Tag or wire key → serviceKey string.
serviceKeyOf(service: | string
| {
readonly key: string
}