The selector type for sub-Events underneath an Event of the given field type.

Instrumented code will typically involve nested scopes of events, including calls across different modules, with different types of events expected in different contexts. To support this, each field type has an associated SubSelector type to identify the kind of events that can occur in the scope where the event is active. This results in a tree of event types represented by a tree of selectors, reflecting the tree of instrumented source components: Each selector of the root selector type specifies a field type, which in turn specifies yet another selector (and, with it, its sub-tree). Use cases which require picking out a linear path through this tree can use Selectors.

If there are no sub-Events under Events with field type f, then you can use NoEventsSelector: type instance SubSelector f = NoEventsSelector.

If you want to retain the set of possible event types as in the parent scope, simply set SubSelector to the very same selector type that the parent selector came from.

A selector type with no values.

This results in an EventBackend which cannot create any Events, which is useful to terminate the tree of event types generated by SubSelector

Generate a rendering function from a SelectorRendering for each top-level selector.

Data needed to define a rendering of Selectors of a given field type.

Generate a SelectorRendering for events with no sub-events.

A nested sequence of selectors, starting from a given root selector family and ending in a selector selecting a given field type.

For example, given:

data FooSelector :: Type -> Type where Foo :: FooSelector FooField
data FooField
type instance SubSelector FooField = BarSelector
data BarSelector :: Type -> Type where Bar :: BarSelector BarField
data BarField
type instance SubSelector BarField = NoEventsSelector

Then Leaf Foo is a sequence Selectors picking out an Event with field type FooField, and Foo :/ Leaf Bar is a sequence of Selectors picking out an Event with field type BarField underneath an Event with field type FooField.

See the selector and field documentation for more details.

Run a computation during an Event selected by the selector.

Parentless Events created during the computation will be marked as children of the new Event.

The Event will be finalized at the end of the computation.

See withRelatedEvent if you need to specify relationships.

Emit an instantaneous Event with the given selector and fields.

See instantRelatedEvent if you need to specify relationships.

A resource allowing instrumentation of code via fields of a given type.

It must be an EventIn some monad to be useful.

Get a reference to the current Event.

Run a computation during an Event selected by the selector and with the given parent and causes.

Parentless Events created during the computation will be marked as children of the new Event.

The Event will be finalized at the end of the computation.

See withEvent if you don't need to specify any relationships.

For a more flexible allocation, see allocateRelatedEvent.

A GeneralAllocate-ion of a new Event, selected by the selector and with the given parent and causes.

The Event with be finalized upon release.

See allocateEventArgs for full flexibility in specifying allocation.

You will likely want to construct a SubEventBackend to create a HasSubEvents context when using this Event.

Emit an instantaneous Event with the given selector and fields and the given parent and causes.

See instantEvent if you don't need to specify any relationships.

See instantEventArgs for full control over Event configuration.

A computational context supporting creating Events from a given selector family.

In typical usage, backend will be kept as a type parameter, to be determined at the call site by the dynamically-scoped ?e11yBackend parameter.

HasEvents can be satisfied by binding the ?e11yBackend implicit parameter to an appropriate value. Proxy selector can be used as a no-op EventBackend, and a pair of backends with the same RootSelector can be used as a backend as well.

A scope containing an event of the given field type.

In typical usage, event will be kept as a type parameter, to be determined at the call site by the dynamically-scoped ?e11yEvent parameter.

HasEvent can be satisfied by binding the ?e11yEvent implicit parameter to an appropriate value. withEvent handles this for you.

A computational context occurring during an event of the given field type.

In typical usage, event will be kept as a type parameter, to be determined at the call site by the dynamically-scoped ?e11yEvent parameter.

HasEventIn can be satisfied by binding the ?e11yEvent implicit parameter to an appropriate value. withEvent handles this for you.

A computational context occurring during an event of the given field type, allowing the creation of new Events according to its SubSelector which are children of the given event.

In typical usage, backend will be kept as a type parameter, to be determined at the call site by the dynamically-scoped ?e11yBackend parameter.

HasSubEvents can be satisfied by binding the ?e11yEvent and ?e11yBackend implicit parameters to appropriate values, the latter via SubEventBackend. withEvent handles this for you.

An EventBackend to use in the context of a running Event.

It creates events selected by the SubSelector of the event's field type, and any parentless events created by it are made children of the event.

A GeneralAllocate-ion of a new Event described by EventParams

The Event with be finalized upon release.

You probably want allocateRelatedEvent.

You will likely want to construct a SubEventBackend to construct a HasSubEvents context when using this Event.

Emit an instantaneous Event described by EventParams

You probably want instantEvent or instantRelatedEvent

Add a field to the running Event.

End the running Event manually, perhaps due to an exception.

It is implementation-specific whether addEventField after finalizeEvent has any effect (but it is not an error).

Subsequent finalizeations, including those that result from leaving the withEvent scope or releasing the allocateEventArgs allocation, will be no-ops.