API reference

@Mediator.Root.Failure — why a mediated message produced no value

@Mediator.Root.Outcome — the value or failure of one message

@Mediator.Root.Violation — one rule a message broke

No failure for none, the failure itself for one, and one flat Aggregate for several.

One sentence saying what went wrong.

Whether the failure is a cancellation.

The outcome of a handler that answers a plain Result.

An outcome holding the handler's own error.

The handler's own error, when the failure is one.

An outcome refused for reason; the failure an open component answers, since it cannot name E.

An outcome holding a value.

One line naming an outcome.

Every violation the failure holds, including those inside an aggregate, in order.

The event written when a message fails; its properties are the name, elapsed milliseconds, and failure.

The event written when a notification is heard; its property is the kind's name.

@Mediator.Behaviors.Logging.Recorder — writes one event per message start and end

The event written when a message starts; its properties are the kind's name and shape.

The event written when a stream ends; its properties are the name, item count, and elapsed milliseconds.

The event written when a message succeeds; its properties are the name and elapsed milliseconds.

A recorder writing to logger under the source PuduLangMediator.

A behavior running the rest of the pipeline under pipeline's retry, timeout, circuit, rate,

hedging, and fallback policies. Each attempt observes the strategies' token through its

context; a failure of the rest of the pipeline reaches the strategies as Raised, except a

cancellation, which stays one.

The resilience behavior of one request kind.

A resilience failure as a mediator failure: the pipeline's own failure unchanged, a

cancellation or crash as one, and a strategy's rejection refused with its description.

A behavior answering Invalid with every violation when validator rejects the request, and

running the rest of the pipeline otherwise.

The validation behavior of one request kind.

The stream validation behavior of one stream kind.

A stream behavior answering Invalid before any item when validator rejects the request.

Every failure of a validation result as a violation, in rule order.

@Mediator.Catalog.Assembly — the open components and options every kind is built with

@Mediator.Catalog.Catalog — the registrations of one mediator, by shape and name

@Mediator.Catalog.Compiled — one kind's composed pipeline, typed and untyped

@Mediator.Catalog.Dispatch — how an envelope of one kind is answered

@Mediator.Catalog.Entry — one kind's registrations, counted, before composition

@Mediator.Catalog.Scope — which failures exception actions observe

Every entry of a table composed with the catalog's assembly.

A catalog with no registrations, publishing with publisher and scoping actions by actionScope.

The catalog with one more registration of layer for the kind name, in order.

Every problem with the catalog's registrations, requests first, then notifications, then streams.

The table with change applied to the route of the kind info names, counting the handlers

and components it adds. A first registration starts from blank; a registration whose route

does not read back through routes belongs to another kind of the same name and is counted

as a collision instead.

How a notification kind's entry is composed once the catalog is complete.

A notification kind's publication: its own handlers and the open ones in registration order,

run by the assembly's publishing strategy.

How a request kind's entry is composed once the catalog is complete.

A request kind's handler wrapped, outermost first, in its exception layers (actions outside

handlers for ForUnhandled, inside them for ForAll), its pre-processors, its

post-processors, and its behaviors in registration order. A layer with no components is left out.

How a stream kind's entry is composed once the catalog is complete.

A stream kind's handler wrapped in its behaviors, open and its own, in registration order.

Several failures of one publication; <1> is their count and <2> their descriptions.

A cancellation; <1> is its reason.

A handler that stopped its thread; <1> is what it said.

A request or stream kind with more than one handler; <1> is its name and <2> the count.

A kind registered without a name.

A message that failed validation; <1> is its violations.

A mediator refused at build time; <1> is its problems.

A message routed to another kind of the same name; <1> is the name.

Two kinds sharing one name; <1> is the name.

A failure raised by a handler; <1> is the error.

A stream reader closed before its stream ended.

A message an open component refused; <1> is the reason.

What separates problems and descriptions listed in one sentence.

An outcome holding a value; <1> is the value.

A message without a handler; <1> is its kind's name.

One validation violation; <1> is the property and <2> the message.

A request or stream kind with components but no handler; <1> is its name.

@Mediator.Context.Context — what one message carries through its pipeline

@Mediator.Context.Key — a typed name for one item

@Mediator.Context.Key — a typed name for one item

Asks the message holding this context to stop. The first reason given is kept.

A fresh context whose message stops when token fires.

Ok while the token has not fired, and Cancelled once it has, so a handler stops with ?.

A context with a token that fires only when cancelled, and no items.

The same context with a token that fires when the original's does, after millis, or when

cancelled itself; items stay shared.

The item under a key, when it is present and was stored through the same key.

The item under a key, or fallback when it is absent.

Whether an item is stored under the key's name.

A key whose items read back as T. Two keys made by separate calls never read each other's

items, even under one name; make each key once and share it.

The names of every stored item, in the order they were first stored.

Sleeps millis, or answers Cancelled as soon as the token fires.

Removes the item under a key.

Stores an item, replacing any item under the same name.

Whether the context's token has fired.

The same context observing another token; items stay shared with the original.

@Mediator.Domain.Census.Census — the registrations counted for one kind

Every problem with one kind's registrations: a missing name, a name two kinds share, and, for

a kind that takes exactly one handler, more than one or components without any.

@Mediator.Domain.Order.Layer — the kinds of component a pipeline orders

@Mediator.Domain.Order.Mark — one registration, open or for one kind

@Mediator.Domain.Order.Pick — a shared open component or the kind's own

The components of one layer that apply to the kind named name, in registration order: every

open one by its index among open components, and each of the kind's own by its index among

the kind's own.

@Mediator.Mediator.Invalid — every reason a mediator could not be built

@Mediator.Mediator.Mediator — every kind's composed pipeline, by shape and name

@Mediator.Mediator.Options — how notifications are published and failures observed

Publishes a notification whose type the caller does not name, with a fresh context.

Publishes a notification whose type the caller does not name, with the given context. A kind

the mediator does not know is answered as heard by nobody.

A mediator of registrations with the default options.

A mediator of registrations, applied in order, or every problem found in them: a kind without

a name, two kinds under one name, and a request or stream kind without exactly one handler.

Every item of a stream request, or its failure.

Sequential publishing, and exception actions that observe only failures no exception handler

answered.

Sends a request whose type the caller does not name, with a fresh context.

Sends a request whose type the caller does not name, with the given context. Read the answer

back with the kind's answerOf.

Every problem in one sentence.

Every registered kind: requests, then notifications, then streams, each in registration order.

Publishes a notification to every handler with a fresh context.

Publishes a notification to its handlers and the open ones, through the mediator's publishing

strategy, with the given context. A kind with no handlers succeeds without running anything.

A reader of a stream request produced on its own thread with the given context, holding at

most capacity items ahead of the consumer. Close it once done with it.

The composed pipeline of a request kind, to call many times without looking it up again;

Unhandled when the kind has no handler and Mismatched when another kind took its name.

Sends a request through its pipeline with a fresh context.

Sends a request through its pipeline with the given context.

Runs a stream request with a fresh context, handing each item to sink until it declines one.

Runs a stream request whose type the caller does not name, handing each packed item to sink

until it declines one. Read items back with the kind's itemOf, and the answer with its answerOf.

Runs a stream request with the given context, handing each item to sink until it declines one.

@Mediator.Message.Answer — what an envelope's handler answered

@Mediator.Message.Delivery — the outcome of an envelope, why there is none, or no listener

@Mediator.Message.Envelope — a message whose type the sender does not name

@Mediator.Message.Fault — why an envelope reached no handler

@Mediator.Message.Info — the name, shape, and tags of one kind

@Mediator.Message.Info — the name, shape, and tags of one kind

@Mediator.Message.Shape — a request with or without a response, a notification, or a stream

The answer holding outcome, readable back only through outcomes.

The failure an undelivered envelope answers, for any error type.

Whether the kind carries tag.

The outcome an answer holds, read through outcomes; None when another kind answered it or

nobody heard it.

The envelope carrying message, readable back only through messages.

The shape's name.

The answer of an envelope that reached no handler.

The answer of a notification envelope whose kind has no handler: a publication nobody heard.

@Mediator.Notification.Handler — receives one notification

@Mediator.Notification.Kind — the typed identity of one notification

@Mediator.Notification.Named — a handler with the name publishers report it by

@Mediator.Notification.Named — a handler with the name publishers report it by

@Mediator.Notification.Route — every handler registered for one kind

The outcome an answer holds, when this kind answered it; a publication nobody heard succeeded.

An envelope carrying notification, for a publisher that does not name its type.

A kind of notification whose handlers fail with E. Make each kind once and share it.

A route with no handlers.

The same kind carrying tags as well, which open components may read.

@Mediator.Open.Behavior — wraps the pipeline of every request

@Mediator.Open.ExceptionAction — observes the failure of every request

@Mediator.Open.Listener — an open notification handler and the name it is reported by

@Mediator.Open.NotificationHandler — receives every notification

@Mediator.Open.PostProcessor — runs after the handler of every request

@Mediator.Open.PreProcessor — runs before the handler of every request

@Mediator.Open.StreamBehavior — wraps the pipeline of every stream

@Mediator.Publisher.Publisher — publishes notifications; a mediator or a test double

@Mediator.Publishing.Bounded — every handler, at most workers at a time

@Mediator.Publishing.Continuing — one handler at a time, every handler, every failure

@Mediator.Publishing.Executor — one handler, ready to run with a context

@Mediator.Publishing.Parallel — every handler on its own thread at once

@Mediator.Publishing.Sequential — one handler at a time, stopping at the first failure

@Mediator.Publishing.Strategy — runs the executors of one publication

@Mediator.Reader.Reader — the consuming end of a stream produced on its own thread

@Mediator.Reader.Step — one item, or the end of the stream with its outcome

Stops the producer, discards what it had produced, and waits for its thread to end.

The next item, waiting for the producer when none is ready; the stream's failure once, when

it ended with one; and None after it ended or the reader was closed.

A reader of what produce emits on a thread of its own, holding at most capacity items

(at least one) ahead of the consumer. The producer waits while the reader is full and stops

once the reader is closed or context is cancelled.

Every item still to come, or the stream's failure.

@Mediator.Registration.Registration — one change to the catalog a mediator is built from

A behavior around the pipeline of one request kind, ordered among every behavior by registration.

An exception action of one request kind, ordered among every exception action by registration.

An exception handler of one request kind; the kind's exception handlers are tried in registration order.

Several registrations as one, applied in order.

The handler of a request kind. A request kind takes exactly one.

A handler of a notification kind, reported to publishing strategies as name. A notification

kind takes any number, ordered among every notification handler by registration.

A behavior around the pipeline of every request kind.

An exception action of every request kind.

A handler of every notification kind, reported to publishing strategies as name. An envelope

reaches it only when its kind is registered with the mediator.

A post-processor of every request kind.

A pre-processor of every request kind.

A behavior around the pipeline of every stream kind.

A post-processor of one request kind, ordered among every post-processor by registration.

A pre-processor of one request kind, ordered among every pre-processor by registration.

A behavior around the pipeline of one stream kind, ordered among every stream behavior by registration.

The handler of a stream kind. A stream kind takes exactly one.

@Mediator.Request.Behavior — wraps the rest of the pipeline for one kind

@Mediator.Request.ExceptionAction — observes a failure that keeps propagating

@Mediator.Request.ExceptionHandler — may answer a value in place of a failure

@Mediator.Request.Handler — answers one request

@Mediator.Request.Kind — the typed identity of one request

@Mediator.Request.Next — the rest of the pipeline, given the context to run it with

@Mediator.Request.PostProcessor — runs after a handler that answered a value

@Mediator.Request.PreProcessor — runs before the handler; a failure stops the request

@Mediator.Request.Route — every component registered for one kind

The outcome an answer holds, when this kind answered it.

A kind of request answering no value.

An envelope carrying request, for a sender that does not name its type.

A kind of request answering R or failing with E. Make each kind once and share it: two

kinds made by separate calls are different kinds, even under one name.

A route with no components.

The same kind carrying tags as well, which open components may read.

@Mediator.Sender.Sender — sends requests and streams; a mediator or a test double

@Mediator.Stream.Behavior — wraps the rest of the stream pipeline for one kind

@Mediator.Stream.Handler — emits the items of one stream request

@Mediator.Stream.Kind — the typed identity of one stream request

@Mediator.Stream.Next — the rest of the stream pipeline

@Mediator.Stream.Route — every component registered for one kind

@Mediator.Stream.Sink — takes one item and answers whether it wants another

The outcome an answer holds, when this kind answered it.

Hands each item to the sink in order until it declines one.

An envelope carrying request, for a sender that does not name its type.

An item an untyped stream emitted, when this kind emitted it.

A kind of stream request emitting T or failing with E. Make each kind once and share it.

A route with no components.

The same kind carrying tags as well, which open components may read.

@Utils.Erasure.Packed — a value whose type only its slot knows

@Utils.Erasure.Slot — the one place a packed value of T reads back

The value packed so that only target reads it back.

A slot of its own: values packed through it read back only through it.

The value packed through source, or None when it was packed through another slot.

@Utils.Shared.Shared — a value changed only under its lock

@Utils.Shared.Shared — a value changed only under its lock

Replaces the value with the first half of what step answers for it, and answers the second

half. No other change to the same value runs between the read and the write.

The value as it stands.

A shared value starting at initial.

Replaces the value with what step answers for it.

The template with each <n> replaced by the nth value, counting from 1, in one pass: text

taken from a value is never filled again. A slot without a value is kept as written.

The message a stopped thread left, or the error itself when it left none.