Return Value Handling

Handler return values are captured in EventResult records and can be consumed as a single value or aggregated across handlers. Repository example files:

Typed return values

Use the event result type to enforce return typing across handlers.

Python
TypeScript
Rust
Go

from abxbus import BaseEvent, EventBus

class DoMathEvent(BaseEvent[int]):
    a: int
    b: int

def add(event: DoMathEvent) -> int:
    return event.a + event.b

bus = EventBus('AppBus')
bus.on(DoMathEvent, add)

event = await bus.emit(DoMathEvent(a=2, b=3)).now()
result = await event.event_result()

import { BaseEvent, EventBus } from 'abxbus'
import { z } from 'zod'

const DoMathEvent = BaseEvent.extend('DoMathEvent', {
  a: z.number(),
  b: z.number(),
  event_result_type: z.number(),
})

const bus = new EventBus('AppBus')
bus.on(DoMathEvent, (event) => event.a + event.b)

const event = bus.emit(DoMathEvent({ a: 2, b: 3 }))
await event.now()
const result = await event.eventResult()

use abxbus::{
    event,
    event_bus::EventBus,
    BaseEvent,
};
use futures::executor::block_on;

event! {
    struct DoMathEvent {
        a: i64,
        b: i64,
        event_result_type: i64,
    }
}

let bus = EventBus::new(Some("AppBus".to_string()));
bus.on(DoMathEvent, |event: DoMathEvent| async move {
    Ok(event.a + event.b)
});

let event = bus.emit(DoMathEvent { a: 2, b: 3, ..Default::default() });
let result = block_on(event.event_result())?;

type DoMathEvent struct {
	A int `json:"a"`
	B int `json:"b"`
}

bus := abxbus.NewEventBus("AppBus", nil)
bus.On(func(event DoMathEvent) (int, error) {
	return event.A + event.B, nil
})

emitted := bus.Emit(DoMathEvent{A: 2, B: 3})
result, err := emitted.EventResult()

Aggregating multiple handler results

When multiple handlers respond to the same event, collect all successful values with the list helpers.

Python
TypeScript
Rust
Go

event = await bus.emit(GetConfigEvent()).now()
values = await event.event_results_list(raise_if_any=False, raise_if_none=False)

const event = bus.emit(GetConfigEvent({}))
const values = await event.eventResultsList({ raise_if_any: false, raise_if_none: false })

use abxbus::{
    base_event::EventResultOptions,
    event,
    event_bus::EventBus,
    BaseEvent,
};
use futures::executor::block_on;
use serde_json::json;

event! {
    struct GetConfigEvent {
        event_result_type: serde_json::Value,
    }
}

let bus = EventBus::new(Some("ConfigBus".to_string()));

bus.on(GetConfigEvent, |_event: GetConfigEvent| async move {
    Ok(json!({"debug": true, "port": 8080}))
});
bus.on(GetConfigEvent, |_event: GetConfigEvent| async move {
    Ok(json!({"debug": false, "timeout": 30}))
});

let event = bus.emit(GetConfigEvent { ..Default::default() });
let values = block_on(event.event_results_list_with_options(EventResultOptions {
    raise_if_any: false,
    raise_if_none: false,
    ..EventResultOptions::default()
}))?;

type GetConfigEvent struct{}

event := bus.Emit(GetConfigEvent{})
values, err := event.EventResultsList(
	&abxbus.EventResultOptions{RaiseIfAny: false, RaiseIfNone: false},
)

Result list options

Python
TypeScript
Rust
Go

await event.event_results_list(raise_if_any=False, raise_if_none=False)
await event.event_results_list(include=lambda result, _: isinstance(result, dict), raise_if_any=False)
completed = await event.wait(timeout=0.25)
await completed.event_results_list()

await event.eventResultsList({ raise_if_any: false, raise_if_none: false })
await event.eventResultsList({ include: (result) => typeof result === 'object', raise_if_any: false })
await event.wait({ timeout: 0.25 }).eventResultsList()

use abxbus::base_event::{EventResultOptions, EventWaitOptions};

event.event_results_list_with_options(EventResultOptions {
    raise_if_any: false,
    raise_if_none: false,
    ..EventResultOptions::default()
}).await?;
let completed = event.wait_with_options(EventWaitOptions {
    timeout: Some(0.25),
    ..EventWaitOptions::default()
}).await?;
completed.event_results_list().await?;

event.EventResultsList(&abxbus.EventResultOptions{
	RaiseIfAny: false,
	RaiseIfNone: false,
})
timeout := 0.25
completed, err := event.Wait(&abxbus.EventWaitOptions{Timeout: &timeout})
if err != nil {
	return err
}
completed.EventResultsList()

Default options are raise_if_any=true and raise_if_none=false in every runtime.
raise_if_any: raise if any handler ended with an error.
raise_if_none: raise only when no handlers returned a valid value after filtering; it does not raise just because one handler returned None/null/undefined.
If every handler errors, only raise_if_any=false plus raise_if_none=false suppresses the error and returns no value/empty list; every other option combination raises.
A single handler error is raised as that error; multiple handler errors are raised as an aggregate/exception-group shape.
Default filtering includes only completed, successful, non-empty scalar/object/list values and excludes forwarded BaseEvent returns.
Go accepts no args for defaults (event.EventResult() / event.EventResultsList()) and a single nil options value is equivalent to defaults.

Per-handler inspection

All runtimes keep per-handler result metadata in addition to the aggregate result helpers.

Python
TypeScript
Rust
Go

by_name = {result.handler_name: result.result for result in event.event_results.values()}

const byHandler = event.event_results

let by_name: std::collections::HashMap<_, _> = event
    .event_results
    .read()
    .values()
    .map(|result| (result.handler.handler_name.clone(), result.result.clone()))
    .collect();

byName := map[string]any{}
for _, result := range event.EventResults {
	byName[result.HandlerName] = result.Result
}

Getting Started

Features

API Reference

Concurrency Control

Integrations

Further Reading

Return Value Handling

Typed return values

Aggregating multiple handler results

Result list options

Per-handler inspection

​Typed return values

​Aggregating multiple handler results

​Result list options

​Per-handler inspection

Typed return values

Aggregating multiple handler results

Result list options

Per-handler inspection