Peer answered — carry its local aggregate.
models
Source src/FleetHealth.ts:594 lines
export class class Reachableclass Reachable {
_tag: 'Reachable';
status: 'ok' | 'degraded';
resources: ReadonlyArray<any>;
}
Peer answered — carry its local aggregate.
Reachable extends import SchemaSchema.const TaggedClass: <Reachable, {}>(identifier?: string) => {
<Tag, Fields>(tag: Tag, fields: Fields, annotations?: Schema.Annotations.Declaration<Reachable, readonly [Schema.TaggedStruct<Tag, Fields>]> | undefined): Schema.Class<Reachable, Schema.TaggedStruct<Tag, Fields>, {}>;
<Tag, S>(tag: Tag, schema: S, annotations?: Schema.Annotations.Declaration<Reachable, readonly [Schema.Struct<{ [K in keyof ({
readonly _tag: Schema.tag<Tag>;
} & S["fields"])]: ({
readonly _tag: Schema.tag<Tag>;
} & S["fields"])[K]; }>]> | undefined): Schema.Class<...>;
}
Defines a schema-backed class with an automatically populated _tag field.
When to use
Use to define class instances that are validated by a schema and participate
in tagged union matching.
Details
The optional identifier parameter overrides the schema identifier;
it defaults to the tag value.
Example (Defining a tagged class)
import { Schema } from "effect"
class Circle extends Schema.TaggedClass<Circle>()("Circle", {
radius: Schema.Number
}) {}
const c = new Circle({ radius: 5 })
console.log(c._tag) // "Circle"
console.log(c.radius) // 5
TaggedClass<class Reachableclass Reachable {
_tag: 'Reachable';
status: 'ok' | 'degraded';
resources: ReadonlyArray<any>;
}
Peer answered — carry its local aggregate.
Reachable>()("Reachable", {
status: Schema.Literals<
readonly ["ok", "degraded"]
>
(property) status: {
literals: L;
members: { readonly [K in keyof L]: Literal<L[K]>; };
mapMembers: (f: (members: readonly [Schema.Literal<'ok'>, Schema.Literal<'degraded'>]) => To) => Schema.Union<{ [K in keyof Readonly<To>]: Readonly<To>[K]; }>;
pick: (literals: L2) => Schema.Literals<L2>;
transform: (to: L2) => Schema.Union<readonly [Schema.decodeTo<Schema.Literal<L2['0']>, Schema.Literal<'ok'>, never, never>, Schema.decodeTo<Schema.Literal<L2['1']>, Schema.Literal<'degraded'>, never, never>]>;
Rebuild: Rebuild;
Iso: Iso;
ast: Ast;
Type: T;
Encoded: E;
DecodingServices: RD;
EncodingServices: RE;
annotate: (annotations: Schema.Annotations.Bottom<'ok' | 'degraded', readonly []>) => Schema.Literals<readonly ['ok', 'degraded']>;
annotateKey: (annotations: Schema.Annotations.Key<'ok' | 'degraded'>) => Schema.Literals<readonly ['ok', 'degraded']>;
check: (checks_0: Check<'ok' | 'degraded'>, ...checks: Array<Check<'ok' | 'degraded'>>) => Schema.Literals<readonly ['ok', 'degraded']>;
rebuild: (ast: Union<Literal>) => Schema.Literals<readonly ['ok', 'degraded']>;
make: (input: 'ok' | 'degraded', options?: Schema.MakeOptions) => 'ok' | 'degraded';
makeOption: (input: 'ok' | 'degraded', options?: Schema.MakeOptions) => Option<'ok' | 'degraded'>;
makeEffect: (input: 'ok' | 'degraded', options?: Schema.MakeOptions) => Effect.Effect<'ok' | 'degraded', 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; <…;
}
import SchemaSchema.function Literals<readonly ["ok", "degraded"]>(literals: readonly ["ok", "degraded"]): Schema.Literals<readonly ["ok", "degraded"]>Creates a union schema from an array of literal values.
Example (Defining status codes)
import { Schema } from "effect"
const schema = Schema.Literals(["active", "inactive", "pending"])
// accepts "active", "inactive", or "pending"
Literals(["ok", "degraded"]),
resources: Schema.$Array<any>(property) resources: {
Type: ReadonlyArray<S["Type"]>;
Encoded: ReadonlyArray<S["Encoded"]>;
DecodingServices: S["DecodingServices"];
EncodingServices: S["EncodingServices"];
Iso: ReadonlyArray<S["Iso"]>;
value: S;
Rebuild: Rebuild;
ast: Ast;
annotate: (annotations: Schema.Annotations.Bottom<ReadonlyArray<any>, readonly []>) => Schema.$Array<any>;
annotateKey: (annotations: Schema.Annotations.Key<ReadonlyArray<any>>) => Schema.$Array<any>;
check: (checks_0: Check<ReadonlyArray<any>>, ...checks: Array<Check<ReadonlyArray<any>>>) => Schema.$Array<any>;
rebuild: (ast: Arrays) => Schema.$Array<any>;
make: (input: ReadonlyArray<any>, options?: Schema.MakeOptions) => ReadonlyArray<any>;
makeOption: (input: ReadonlyArray<any>, options?: Schema.MakeOptions) => Option<ReadonlyArray<any>>;
makeEffect: (input: ReadonlyArray<any>, options?: Schema.MakeOptions) => Effect.Effect<ReadonlyArray<any>, 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; <…;
}
import SchemaSchema.Array<any>(self: any): Schema.$Array<any>
export Array
Defines a ReadonlyArray schema for a given element schema.
Example (Defining an array of strings)
import { Schema } from "effect"
const schema = Schema.Array(Schema.String)
const result = Schema.decodeUnknownSync(schema)(["a", "b", "c"])
console.log(result)
// [ 'a', 'b', 'c' ]
Array(import NodeStatusNodeStatus.resourceReadiness),
}) {}
Referenced by 1 symbols