miruken

type AcceptPromiseResultFunc ¶ added in v0.10.0

type AcceptPromiseResultFunc func(
	pa *promise.Promise[any],
) *promise.Promise[any]

AcceptPromiseResultFunc adjusts promise callback results.

type AcceptResultFunc ¶

type AcceptResultFunc func(
	result any,
	composer Handler,
) HandleResult

AcceptResultFunc accepts or rejects callback results.

type Batched ¶ added in v0.10.0

type Batched[T any] struct {
	Source   T
	Callback Callback
}

Batched wraps a Callback participating in a batch operation.

type Binding ¶

type Binding interface {
	Filtered
	Key() any
	Strict() bool
	SkipFilters() bool
	Async() bool
	Exported() bool
	Metadata() []any
	LogicalOutputType() reflect.Type
	Invoke(
		ctx HandleContext,
		initArgs ...any,
	) ([]any, *promise.Promise[[]any], error)
}

Binding connects a Callback to a handler.

type BindingBase ¶ added in v0.21.0

type BindingBase struct {
	FilteredScope
	// contains filtered or unexported fields
}

BindingBase implements common binding contract.

func (b *BindingBase) Async() bool

func (b *BindingBase) Metadata() []any

func (b *BindingBase) SkipFilters() bool

func (b *BindingBase) Strict() bool

type BindingGroup ¶ added in v0.10.0

type BindingGroup struct{}

BindingGroup marks bindings that aggregate one or more binding metadata.

func (BindingGroup) DefinesBindingGroup()

type BindingParser ¶ added in v0.22.0

type BindingParser interface {
	// contains filtered or unexported methods
}

BindingParser is an extension for binding customizations.

type BindingParserFunc ¶ added in v0.22.0

type BindingParserFunc func(
	index int,
	field *reflect.StructField,
	binding any,
) (bound bool, err error)

BindingParserFunc implements a BindingParser using a function.

type BindingReducer ¶

type BindingReducer func(
	binding Binding,
	result HandleResult,
) (HandleResult, bool)

BindingReducer aggregates Binding results.

type BivariantPolicy ¶

type BivariantPolicy struct {
	FilteredScope
	// contains filtered or unexported fields
}

BivariantPolicy matches related input and output values.

func (p *BivariantPolicy) AcceptResults(
	results []any,
) (any, HandleResult, []Effect, []any)

func (p *BivariantPolicy) Less(
	binding, otherBinding Binding,
) bool

func (p *BivariantPolicy) MatchesKey(
	key, otherKey any,
	invariant bool,
) (matches, exact bool)

func (p *BivariantPolicy) NewFuncBinding(
	fun reflect.Value,
	spec *bindingSpec,
	key any,
) (Binding, error)

func (p *BivariantPolicy) NewMethodBinding(
	method *reflect.Method,
	spec *bindingSpec,
	key any,
) (Binding, error)

func (p *BivariantPolicy) Strict() bool

func (p *BivariantPolicy) VariantKey(
	key any,
) (bool, bool)

type Builder ¶

type Builder interface {
	BuildUp(Handler) Handler
}

Builder augments a Handler.

func CallWith(semantics SemanticFlags) Builder

func ComposeBuilders(builder Builder, builders ...Builder) Builder

func PipeBuilders(builder Builder, builders ...Builder) Builder

func ProvideFilters(providers ...FilterProvider) Builder

func UseFilters(filters ...Filter) Builder

type BuilderFunc ¶

type BuilderFunc func(Handler) Handler

BuilderFunc promotes a function to Builder.

var NoBatch BuilderFunc = func(handler Handler) Handler {
	if internal.IsNil(handler) {
		panic("handler cannot be nil")
	}
	return &noBatchHandler{handler}
}

func Axis(axis TraversingAxis) BuilderFunc

func Options(options any) BuilderFunc

func Reentrant(filter FilterFunc) BuilderFunc

func With(values ...any) BuilderFunc

func (f BuilderFunc) BuildUp(
	handler Handler,
) Handler

type Callback ¶

type Callback interface {
	ConstraintSource
	Key() any
	Source() any
	Target() any
	TargetForWrite() any
	Policy() Policy
	ResultCount() int
	Result(many bool) (any, *promise.Promise[any])
	SetResult(result any)
	ReceiveResult(
		result any,
		strict bool,
		composer Handler,
	) HandleResult
}

Callback represents an intention.

type CallbackArg ¶ added in v0.4.0

type CallbackArg struct{}

CallbackArg returns the raw callback.

type CallbackBase ¶

type CallbackBase struct {
	// contains filtered or unexported fields
}

CallbackBase is abstract Callback implementation.

func (c *CallbackBase) AddResult(
	result any,
	composer Handler,
) HandleResult

func (c *CallbackBase) Constraints() []Constraint

func (c *CallbackBase) ReceiveResult(
	result any,
	strict bool,
	composer Handler,
) HandleResult

func (c *CallbackBase) Result(
	many bool,
) (any, *promise.Promise[any])

func (c *CallbackBase) ResultCount() int

func (c *CallbackBase) SetAcceptPromiseResult(
	accept AcceptPromiseResultFunc,
)

func (c *CallbackBase) SetAcceptResult(
	accept AcceptResultFunc,
)

func (c *CallbackBase) SetResult(result any)

func (c *CallbackBase) Source() any

func (c *CallbackBase) Target() any

func (c *CallbackBase) TargetForWrite() any

type CallbackBuilder ¶

type CallbackBuilder struct {
	// contains filtered or unexported fields
}

CallbackBuilder builds common CallbackBase.

func (b *CallbackBuilder) CallbackBase() CallbackBase

func (b *CallbackBuilder) IntoTarget(
	target any,
) *CallbackBuilder

func (b *CallbackBuilder) WithConstraints(
	constraints ...any,
) *CallbackBuilder

type CallbackGuard ¶

type CallbackGuard interface {
	CanDispatch(
		handler any,
		binding Binding,
	) (reset func(), approved bool)
}

CallbackGuard detects and prevents circular Callback dispatch.

type CallbackSemantics ¶

type CallbackSemantics struct {
	Composition
	// contains filtered or unexported fields
}

CallbackSemantics captures semantic options.

func GetSemantics(handler Handler) *CallbackSemantics

func (c *CallbackSemantics) CanBatch() bool

func (c *CallbackSemantics) CanFilter() bool

func (c *CallbackSemantics) CanInfer() bool

func (c *CallbackSemantics) HasOption(options SemanticFlags) bool

func (c *CallbackSemantics) IsSpecified(options SemanticFlags) bool

func (c *CallbackSemantics) MergeInto(semantics *CallbackSemantics)

func (c *CallbackSemantics) SetOption(options SemanticFlags, enabled bool)

type CallerFunc ¶ added in v0.30.11

type CallerFunc func(Handler, ...any) ([]any, *promise.Promise[[]any], error)

CallerFunc is a function that invokes a handler method. The first argument is the handler instance. The remaining arguments become the initial arguments to the handler method. All remaining handler method arguments are resolved from the context.

func MakeCaller(fun any) (CallerFunc, error)

type CanceledError ¶ added in v0.26.0

type CanceledError struct {
	Message string
	Cause   error
}

CanceledError reports a canceled operation.

func (e *CanceledError) Error() string

func (e *CanceledError) Unwrap() error

type Cascade ¶ added in v0.30.105

type Cascade struct {
	// contains filtered or unexported fields
}

Cascade is a standard Effect for cascading callbacks.

func CascadeCallbacks(callbacks ...any) *Cascade

func (c *Cascade) Apply(
	ctx HandleContext,
) (promise.Reflect, error)

func (c *Cascade) Greedy(
	greedy bool,
) *Cascade

func (c *Cascade) WithConstraints(
	constraints ...any,
) *Cascade

func (c *Cascade) WithHandler(
	handler Handler,
) *Cascade

type Composition ¶

type Composition struct {
	Trampoline
}

Composition wraps a callback for composition.

func (c *Composition) Dispatch(
	handler any,
	greedy bool,
	composer Handler,
) HandleResult

type CompositionScope ¶ added in v0.22.0

type CompositionScope struct {
	Handler
}

CompositionScope decorates a Handler for composition.

func (c *CompositionScope) Handle(
	callback any,
	greedy bool,
	composer Handler,
) HandleResult

type Constraint ¶ added in v0.25.0

type Constraint interface {
	// Required determines if Constraint must be satisfied.
	// If it is not required, it will accept Callback's without it.
	Required() bool

	// Implied determines if Constraint can be satisfied with just HandleContext.
	Implied() bool

	// Satisfies checks if the required Constraint is satisfied.
	// if implied, nil will be passed for `required` Constraint parameter.
	Satisfies(required Constraint, ctx HandleContext) bool
}

Constraint manages BindingMetadata assertions.

type ConstraintProvider ¶

type ConstraintProvider struct {
	// contains filtered or unexported fields
}

ConstraintProvider is a FilterProvider for constraints.

func (c *ConstraintProvider) Constraints() []Constraint

func (c *ConstraintProvider) Filters(
	binding Binding,
	callback any,
	composer Handler,
) ([]Filter, error)

func (c *ConstraintProvider) Required() bool

type ConstraintSource ¶ added in v0.25.0

type ConstraintSource interface {
	Constraints() []Constraint
}

ConstraintSource returns one or more Constraint.

type ConstructorBinder ¶

type ConstructorBinder interface {
	NewCtorBinding(
		typ reflect.Type,
		ctor *reflect.Method,
		inits []*reflect.Method,
		spec *bindingSpec,
		key any,
	) (Binding, error)
}

ConstructorBinder creates constructor Binding's.

type ContravariantPolicy ¶

type ContravariantPolicy struct {
	FilteredScope
}

ContravariantPolicy matches related input values.

func (p *ContravariantPolicy) AcceptResults(
	results []any,
) (any, HandleResult, []Effect, []any)

func (p *ContravariantPolicy) Less(
	binding, otherBinding Binding,
) bool

func (p *ContravariantPolicy) MatchesKey(
	key, otherKey any,
	invariant bool,
) (matches, exact bool)

func (p *ContravariantPolicy) NewFuncBinding(
	fun reflect.Value,
	spec *bindingSpec,
	key any,
) (Binding, error)

func (p *ContravariantPolicy) NewMethodBinding(
	method *reflect.Method,
	spec *bindingSpec,
	key any,
) (Binding, error)

func (p *ContravariantPolicy) Strict() bool

func (p *ContravariantPolicy) VariantKey(
	key any,
) (variant, unknown bool)

type CovariantPolicy ¶

type CovariantPolicy struct {
	FilteredScope
}

CovariantPolicy matches related output values.

func (p *CovariantPolicy) AcceptResults(
	results []any,
) (result any, accepted HandleResult, effects []Effect, cascade []any)

func (p *CovariantPolicy) Less(
	binding, otherBinding Binding,
) bool

func (p *CovariantPolicy) MatchesKey(
	key, otherKey any,
	invariant bool,
) (matches, exact bool)

func (p *CovariantPolicy) NewCtorBinding(
	typ reflect.Type,
	ctor *reflect.Method,
	inits []*reflect.Method,
	spec *bindingSpec,
	key any,
) (Binding, error)

func (p *CovariantPolicy) NewFuncBinding(
	fun reflect.Value,
	spec *bindingSpec,
	key any,
) (Binding, error)

func (p *CovariantPolicy) NewMethodBinding(
	method *reflect.Method,
	spec *bindingSpec,
	key any,
) (Binding, error)

func (p *CovariantPolicy) Strict() bool

func (p *CovariantPolicy) VariantKey(
	key any,
) (variant, unknown bool)

type Creates ¶

type Creates struct {
	CallbackBase
	// contains filtered or unexported fields
}

Creates instances covariantly.

func (c *Creates) Dispatch(
	handler any,
	greedy bool,
	composer Handler,
) HandleResult

func (c *Creates) Key() any

func (c *Creates) Policy() Policy

func (c *Creates) String() string

type CreatesBuilder ¶

type CreatesBuilder struct {
	CallbackBuilder
	// contains filtered or unexported fields
}

CreatesBuilder builds Creates callbacks.

func (b *CreatesBuilder) New() *Creates

func (b *CreatesBuilder) WithKey(
	key any,
) *CreatesBuilder

type CurrentHandlerInfoFactoryProvider ¶ added in v0.30.79

type CurrentHandlerInfoFactoryProvider struct {
	Factory HandlerInfoFactory
}

CurrentHandlerInfoFactoryProvider Resolves the current HandlerInfoFactory

func (f *CurrentHandlerInfoFactoryProvider) CabBatch() bool

func (f *CurrentHandlerInfoFactoryProvider) Handle(
	callback any,
	greedy bool,
	composer Handler,
) HandleResult

func (f *CurrentHandlerInfoFactoryProvider) SuppressDispatch()

type DependencyArg ¶

type DependencyArg struct {
	// contains filtered or unexported fields
}

DependencyArg is a parameter resolved at runtime.

func (d DependencyArg) Metadata() []any

func (d DependencyArg) Optional() bool

func (d DependencyArg) Promise() bool

func (d DependencyArg) Strict() bool

type DependencyResolver ¶

type DependencyResolver interface {
	Resolve(
		reflect.Type,
		DependencyArg,
		HandleContext,
	) (reflect.Value, *promise.Promise[reflect.Value], error)
}

DependencyResolver defines how an argument value is retrieved.

type DiKey ¶

type DiKey struct {
	In  any
	Out any
}

DiKey represents a key with input and output parts.

type Disposable ¶

type Disposable interface {
	Dispose()
}

type DisposableFunc ¶

type DisposableFunc func()

func (f DisposableFunc) Dispose()

type Effect ¶ added in v0.30.113

type Effect interface {
	Apply(HandleContext) (promise.Reflect, error)
}

Effect describes an action to be performed. Effects are additional outputs from a Handler. These actions generally represent interactions with external entities i.e. databases and other IO.

func MakeEffect(
	effect any,
	require bool,
) (Effect, error)

func MakeEffects(
	require bool,
	effects []any,
) ([]Effect, []any, error)

type Filter ¶

type Filter interface {
	Order() int
	Next(

		self Filter,
		next Next,
		ctx HandleContext,
		provider FilterProvider,
	) ([]any, *promise.Promise[[]any], error)
}

Filter defines a middleware step in a pipeline.

type FilterAdapter ¶ added in v0.30.23

type FilterAdapter struct{}

FilterAdapter is an adapter for implementing a Filter using late binding method resolution.

func (l FilterAdapter) Next(
	self Filter,
	next Next,
	ctx HandleContext,
	provider FilterProvider,
) ([]any, *promise.Promise[[]any], error)

type FilterFunc ¶

type FilterFunc func(
	callback any,
	greedy bool,
	composer Handler,
	proceed ProceedFunc,
) HandleResult

FilterFunc defines a function that can intercept a callback.

func (f FilterFunc) BuildUp(handler Handler) Handler

type FilterInstanceProvider ¶

type FilterInstanceProvider struct {
	// contains filtered or unexported fields
}

FilterInstanceProvider provides existing Filters.

func NewFilterInstanceProvider(
	required bool,
	filters ...Filter,
) *FilterInstanceProvider

func (f *FilterInstanceProvider) Filters(
	binding Binding,
	callback any,
	composer Handler,
) ([]Filter, error)

func (f *FilterInstanceProvider) Required() bool

type FilterOptions ¶

type FilterOptions struct {
	Providers   []FilterProvider
	SkipFilters Option[bool]
}

FilterOptions are used to control Filter processing.

type FilterProvider ¶

type FilterProvider interface {
	Required() bool
	Filters(
		binding Binding,
		callback any,
		composer Handler,
	) ([]Filter, error)
}

FilterProvider provides one or more Filter's.

type Filtered ¶

type Filtered interface {
	Filters() []FilterProvider
	AddFilters(providers ...FilterProvider)
	RemoveFilters(providers ...FilterProvider)
	RemoveAllFilters()
}

Filtered is a container of Filters.

type FilteredScope ¶

type FilteredScope struct {
	// contains filtered or unexported fields
}

FilteredScope implements a container of Filters.

func (f *FilteredScope) AddFilters(providers ...FilterProvider)

func (f *FilteredScope) Filters() []FilterProvider

func (f *FilteredScope) RemoveAllFilters()

func (f *FilteredScope) RemoveFilters(providers ...FilterProvider)

type FromOptions ¶

type FromOptions struct{}

FromOptions is a DependencyResolver for option arguments.

func (o FromOptions) Resolve(
	typ reflect.Type,
	dep DependencyArg,
	ctx HandleContext,
) (options reflect.Value, _ *promise.Promise[reflect.Value], err error)

func (o FromOptions) Validate(
	typ reflect.Type,
	dep DependencyArg,
) error

type FuncBinder ¶ added in v0.3.0

type FuncBinder interface {
	NewFuncBinding(
		fun reflect.Value,
		spec *bindingSpec,
		key any,
	) (Binding, error)
}

FuncBinder creates a binding to a function.

type FuncBindingError ¶ added in v0.3.0

type FuncBindingError struct {
	// contains filtered or unexported fields
}

FuncBindingError reports a failed function binding.

func (e *FuncBindingError) Error() string

func (e *FuncBindingError) Func() reflect.Value

func (e *FuncBindingError) Unwrap() error

type FuncSpec ¶ added in v0.30.25

type FuncSpec struct {
	// contains filtered or unexported fields
}

FuncSpec creates a HandlerInfo from a single function.

func (s FuncSpec) Func() reflect.Value

func (s FuncSpec) PkgPath() string

func (s FuncSpec) String() string

type HandleContext ¶

type HandleContext struct {
	Handler  any
	Callback Callback
	Binding  Binding
	Composer Handler
	Greedy   bool
}

HandleContext allows inspection of the current Callback.

func (c HandleContext) Handle(
	callback any,
	greedy bool,
	composer Handler,
) HandleResult

type HandleResult ¶

type HandleResult struct {
	// contains filtered or unexported fields
}

HandleResult describes the result of an operation.

func DispatchCallback(
	handler any,
	callback any,
	greedy bool,
	composer Handler,
) HandleResult

func DispatchPolicy(
	handler any,
	callback Callback,
	greedy bool,
	composer Handler,
) HandleResult

func (r HandleResult) And(other HandleResult) HandleResult

func (r HandleResult) AndBlock(other HandleResult) HandleResult

func (r HandleResult) Error() error

func (r HandleResult) Handled() bool

func (r HandleResult) IsError() bool

func (r HandleResult) Or(other HandleResult) HandleResult

func (r HandleResult) OrBlock(block HandleResultBlock) HandleResult

func (r HandleResult) Otherwise(
	block HandleResultBlock,
) HandleResult

func (r HandleResult) OtherwiseHandledIf(
	handled bool,
) HandleResult

func (r HandleResult) OtherwiseIf(
	condition bool,
	block HandleResultBlock,
) HandleResult

func (r HandleResult) Stop() bool

func (r HandleResult) Then(
	block HandleResultBlock,
) HandleResult

func (r HandleResult) ThenIf(
	condition bool,
	block HandleResultBlock,
) HandleResult

func (r HandleResult) WithError(err error) HandleResult

func (r HandleResult) WithoutError() HandleResult

type HandleResultBlock ¶

type HandleResultBlock func() HandleResult

HandleResultBlock provides another HandleResult.

type Handler ¶

type Handler interface {
	Handle(
		callback any,
		greedy bool,
		composer Handler,
	) HandleResult
}

Handler is the uniform metaphor for processing.

func AddHandlers(
	parent Handler,
	handlers ...any,
) Handler

func BuildUp(handler Handler, builders ...Builder) Handler

func NewInferenceHandler(
	factory HandlerInfoFactory,
	specs []HandlerSpec,
) Handler

func NewProvider(value any) Handler

func ToHandler(handler any) Handler

type HandlerAxis ¶

type HandlerAxis interface {
	Handler
	HandleAxis(
		axis TraversingAxis,
		callback any,
		greedy bool,
		composer Handler,
	) HandleResult
}

HandlerAxis extends Handler with traversal behavior.

type HandlerInfo ¶ added in v0.30.25

type HandlerInfo struct {
	FilteredScope
	// contains filtered or unexported fields
}

HandlerInfo describes the structure of a Handler.

func (h *HandlerInfo) Dispatch(
	policy Policy,
	handler any,
	callback Callback,
	greedy bool,
	composer Handler,
	guard CallbackGuard,
) (result HandleResult)

func (h *HandlerInfo) Spec() HandlerSpec

type HandlerInfoError ¶ added in v0.30.25

type HandlerInfoError struct {
	Spec  HandlerSpec
	Cause error
}

HandlerInfoError reports a failed HandlerInfo.

func (e *HandlerInfoError) Error() string

func (e *HandlerInfoError) Unwrap() error

type HandlerInfoFactory ¶ added in v0.30.25

type HandlerInfoFactory interface {
	HandlerInfoProvider
	Spec(src any) HandlerSpec
	Register(src any) (*HandlerInfo, bool, error)
}

HandlerInfoFactory registers HandlerInfo's.

func CurrentHandlerInfoFactory(
	handler Handler,
) HandlerInfoFactory

type HandlerInfoFactoryBuilder ¶ added in v0.30.25

type HandlerInfoFactoryBuilder struct {
	// contains filtered or unexported fields
}

HandlerInfoFactoryBuilder build the HandlerInfoFactory.

func (b *HandlerInfoFactoryBuilder) Build() HandlerInfoFactory

func (b *HandlerInfoFactoryBuilder) Observers(
	observers ...HandlerInfoObserver,
) *HandlerInfoFactoryBuilder

func (b *HandlerInfoFactoryBuilder) Parsers(
	parsers ...BindingParser,
) *HandlerInfoFactoryBuilder

type HandlerInfoObserver ¶ added in v0.30.25

type HandlerInfoObserver interface {
	BindingCreated(
		policy Policy,
		handlerInfo *HandlerInfo,
		binding Binding,
	)
	HandlerInfoCreated(handlerInfo *HandlerInfo)
}

HandlerInfoObserver observes HandlerInfo creation.

type HandlerInfoObserverFunc ¶ added in v0.30.25

type HandlerInfoObserverFunc func(Policy, *HandlerInfo, Binding)

func (f HandlerInfoObserverFunc) BindingCreated(
	policy Policy,
	handlerInfo *HandlerInfo,
	binding Binding,
)

type HandlerInfoProvider ¶ added in v0.30.25

type HandlerInfoProvider interface {
	Get(src any) *HandlerInfo
}

HandlerInfoProvider returns HandlerInfo's.

type HandlerSpec ¶ added in v0.3.0

type HandlerSpec interface {
	fmt.Stringer
	PkgPath() string
	// contains filtered or unexported methods
}

HandlerSpec is Factory for HandlerInfo and associated metadata.

type Handles ¶

type Handles struct {
	CallbackBase
	// contains filtered or unexported fields
}

Handles callbacks contravariantly.

func (h *Handles) CanBatch() bool

func (h *Handles) CanDispatch(
	handler any,
	binding Binding,
) (reset func(), approved bool)

func (h *Handles) CanFilter() bool

func (h *Handles) CanInfer() bool

func (h *Handles) Dispatch(
	handler any,
	greedy bool,
	composer Handler,
) HandleResult

func (h *Handles) Key() any

func (h *Handles) Policy() Policy

func (h *Handles) Source() any

func (h *Handles) String() string

type HandlesBuilder ¶

type HandlesBuilder struct {
	CallbackBuilder
	// contains filtered or unexported fields
}

HandlesBuilder builds Handles callbacks.

func (b *HandlesBuilder) New() *Handles

func (b *HandlesBuilder) WithCallback(
	callback any,
) *HandlesBuilder

type Init ¶ added in v0.30.28

type Init struct{}

Init marks a method as an initializer.

type Key ¶ added in v0.30.35

type Key string

Key is a miruken.DependencyResolver for resolving values referenced by a string key.

func (k *Key) InitWithTag(tag reflect.StructTag) error

func (k Key) Resolve(
	typ reflect.Type,
	dep DependencyArg,
	ctx HandleContext,
) (v reflect.Value, pv *promise.Promise[reflect.Value], err error)

type Lifestyle ¶

type Lifestyle struct{}

Lifestyle provides common lifestyle functionality.

func (l *Lifestyle) Order() int

type LifestyleInit ¶ added in v0.30.28

type LifestyleInit interface {
	InitLifestyle(Binding) error
}

LifestyleInit initializes a Lifestyle from Binding info.

type LifestyleProvider ¶

type LifestyleProvider struct {
	// contains filtered or unexported fields
}

LifestyleProvider is a FilterProvider of lifestyles.

func (l *LifestyleProvider) AppliesTo(
	callback Callback,
) bool

func (l *LifestyleProvider) Filters(
	binding Binding,
	callback any,
	composer Handler,
) ([]Filter, error)

func (l *LifestyleProvider) FiltersAssigned() bool

func (l *LifestyleProvider) Required() bool

func (l *LifestyleProvider) SetFilters(filters ...Filter)

type Metadata ¶

type Metadata map[any]any

Metadata matches against kev/value pairs.

func (m *Metadata) Implied() bool

func (m *Metadata) InitWithTag(
	tag reflect.StructTag,
) (err error)

func (m *Metadata) Required() bool

func (m *Metadata) Satisfies(required Constraint, _ HandleContext) bool

type MethodBinder ¶

type MethodBinder interface {
	NewMethodBinding(
		method *reflect.Method,
		spec *bindingSpec,
		key any,
	) (Binding, error)
}

MethodBinder creates a binding a method.

type MethodBindingError ¶

type MethodBindingError struct {
	Method *reflect.Method
	Cause  error
}

MethodBindingError reports a failed method binding.

func (e *MethodBindingError) Error() string

func (e *MethodBindingError) Unwrap() error

type MutableHandlers ¶ added in v0.22.0

type MutableHandlers struct {
	// contains filtered or unexported fields
}

MutableHandlers manages a mutable list of Handlers.

func (m *MutableHandlers) AppendHandlers(
	handlers ...any,
) *MutableHandlers

func (m *MutableHandlers) Handle(
	callback any,
	greedy bool,
	composer Handler,
) HandleResult

func (m *MutableHandlers) Handlers() []any

func (m *MutableHandlers) InsertHandlers(
	index int,
	handlers ...any,
) *MutableHandlers

func (m *MutableHandlers) RemoveHandlers(
	handlers ...any,
) *MutableHandlers

func (m *MutableHandlers) ResetHandlers(
	handlers ...any,
) *MutableHandlers

func (m *MutableHandlers) SuppressDispatch()

type Named ¶

type Named string

Named matches against a name.

func (n *Named) Implied() bool

func (n *Named) InitWithTag(tag reflect.StructTag) error

func (n *Named) Name() string

func (n *Named) Required() bool

func (n *Named) Satisfies(required Constraint, _ HandleContext) bool

type Next ¶

type Next func(
	composer Handler,
	proceed bool,
	values ...any,
) ([]any, *promise.Promise[[]any], error)

Next advances to the next step in a pipeline. The optional composer replaces the Handler in the next step. The optional values provide dependencies to the next step.

func (n Next) Abort() ([]any, *promise.Promise[[]any], error)

func (n Next) Fail(err error) ([]any, *promise.Promise[[]any], error)

func (n Next) Handle(
	callback any,
	greedy bool,
	composer Handler,
) ([]any, *promise.Promise[[]any], error)

func (n Next) Pipe(values ...any) ([]any, *promise.Promise[[]any], error)

func (n Next) PipeAwait(values ...any) []any

func (n Next) PipeComposer(
	composer Handler,
	values ...any,
) ([]any, *promise.Promise[[]any], error)

func (n Next) PipeComposerAwait(
	composer Handler,
	values ...any,
) []any

type NotHandledError ¶

type NotHandledError struct {
	Callback any
}

NotHandledError reports a failed callback.

func (e *NotHandledError) Error() string

type Option ¶ added in v0.11.0

type Option[T any] struct {
	// contains filtered or unexported fields
}

Option provides an explicit representation of an optional value when the Zero value is not sufficient to distinguish unset values.

func Set[T any](val T) Option[T]

func (o *Option[T]) MergeFrom(option any) bool

func (o *Option[T]) Set() bool

func (o *Option[T]) SetValue(val T)

func (o *Option[T]) Value() T

func (o *Option[T]) ValueOrDefault(val T) T

type Optional ¶

type Optional struct{}

Optional marks a dependency not required.

type Policy ¶

type Policy interface {
	Filtered
	Strict() bool
	Less(binding, otherBinding Binding) bool
	VariantKey(key any) (bool, bool)
	MatchesKey(key, otherKey any, invariant bool) (bool, bool)
	AcceptResults(results []any) (any, HandleResult, []Effect, []any)
}

Policy manages behaviors and callback Binding's.

type PolicyDispatch ¶

type PolicyDispatch interface {
	DispatchPolicy(
		policy Policy,
		callback Callback,
		greedy bool,
		composer Handler,
	) HandleResult
}

PolicyDispatch customizes Callback Policy dispatch.

type Predicate ¶

type Predicate[T any] func(T) bool

Predicate represents a generic selector.

func CombinePredicates[T any](
	predicate Predicate[T],
	predicates ...Predicate[T],
) Predicate[T]

type ProceedFunc ¶ added in v0.7.0

type ProceedFunc func() HandleResult

ProceedFunc calls the next filter in the pipeline.

type Provides ¶

type Provides struct {
	CallbackBase
	// contains filtered or unexported fields
}

Provides results covariantly.

func (p *Provides) Binding() Binding

func (p *Provides) CanDispatch(
	handler any,
	binding Binding,
) (reset func(), approved bool)

func (p *Provides) Dispatch(
	handler any,
	greedy bool,
	composer Handler,
) (result HandleResult)

func (p *Provides) Key() any

func (p *Provides) Owner() any

func (p *Provides) Parent() *Provides

func (p *Provides) Policy() Policy

func (p *Provides) Resolve(
	handler Handler,
	many bool,
) (any, *promise.Promise[any], error)

func (p *Provides) String() string

type ProvidesBuilder ¶

type ProvidesBuilder struct {
	CallbackBuilder
	// contains filtered or unexported fields
}

ProvidesBuilder builds Provides callbacks.

func (b *ProvidesBuilder) Build() Provides

func (b *ProvidesBuilder) ForOwner(
	owner any,
) *ProvidesBuilder

func (b *ProvidesBuilder) New() *Provides

func (b *ProvidesBuilder) WithConstraints(
	constraints ...any,
) *CallbackBuilder

func (b *ProvidesBuilder) WithKey(
	key any,
) *ProvidesBuilder

func (b *ProvidesBuilder) WithParent(
	parent *Provides,
) *ProvidesBuilder

type Qualifier ¶

type Qualifier[T any] struct{}

Qualifier matches against a type.

func (q Qualifier[T]) Implied() bool

func (q Qualifier[T]) Required() bool

func (q Qualifier[T]) Satisfies(required Constraint, _ HandleContext) bool

type RejectedError ¶

type RejectedError struct {
	Callback any
}

RejectedError reports a rejected callback.

func (e *RejectedError) Error() string

type Resolves ¶ added in v0.10.0

type Resolves struct {
	Provides
	// contains filtered or unexported fields
}

Resolves extends Provides semantics to dispatch a Callback on the resolved handler.

func (r *Resolves) Callback() Callback

func (r *Resolves) CanDispatch(
	handler any,
	binding Binding,
) (reset func(), approved bool)

func (r *Resolves) Succeeded() bool

type ResolvesBuilder ¶ added in v0.10.0

type ResolvesBuilder struct {
	ProvidesBuilder
	// contains filtered or unexported fields
}

ResolvesBuilder builds Resolves callbacks.

func (b *ResolvesBuilder) New() *Resolves

func (b *ResolvesBuilder) WithCallback(
	callback Callback,
) *ResolvesBuilder

func (b *ResolvesBuilder) WithGreedy(
	greedy bool,
) *ResolvesBuilder

type SemanticFlags ¶

type SemanticFlags uint8

SemanticFlags enumerates semantic options.

const (
	SemanticNone      SemanticFlags = 0
	SemanticBroadcast SemanticFlags = 1 << iota
	SemanticBestEffort
	SemanticNotify = SemanticBroadcast | SemanticBestEffort
)

type Single ¶ added in v0.22.0

type Single struct {
	LifestyleProvider
	// contains filtered or unexported fields
}

Single LifestyleProvider providing same instance.

func (s *Single) InitLifestyle(binding Binding) error

func (s *Single) InitWithTag(tag reflect.StructTag) error

type SkipFilters ¶

type SkipFilters struct{}

SkipFilters skips all non-required filters.

type Strict ¶

type Strict struct{}

Strict Binding's do not expand results.

type Timespan ¶ added in v0.11.0

type Timespan time.Duration

func (t Timespan) Format(format string) string

type Trampoline ¶

type Trampoline struct {
	// contains filtered or unexported fields
}

func (t *Trampoline) Callback() any

func (t *Trampoline) CanBatch() bool

func (t *Trampoline) CanDispatch(
	handler any,
	binding Binding,
) (reset func(), approved bool)

func (t *Trampoline) CanFilter() bool

func (t *Trampoline) CanInfer() bool

func (t *Trampoline) Dispatch(
	callback any,
	handler any,
	greedy bool,
	composer Handler,
) HandleResult

func (t *Trampoline) Policy() Policy

func (t *Trampoline) Result(
	many bool,
) (any, *promise.Promise[any])

func (t *Trampoline) SetResult(result any)

func (t *Trampoline) Source() any

type TraversalCircularityError ¶

type TraversalCircularityError struct {
	// contains filtered or unexported fields
}

TraversalCircularityError reports a traversal circularity.

func (e TraversalCircularityError) Culprit() Traversing

func (e TraversalCircularityError) Error() string

type TraversalVisitor ¶

type TraversalVisitor interface {
	VisitTraversal(node Traversing) (stop bool, err error)
}

TraversalVisitor is called during traversal.

type TraversalVisitorFunc ¶

type TraversalVisitorFunc func(node Traversing) (stop bool, err error)

func (f TraversalVisitorFunc) VisitTraversal(node Traversing) (bool, error)

type Traversing ¶

type Traversing interface {
	Parent() Traversing
	Children() []Traversing
	Traverse(axis TraversingAxis, visitor TraversalVisitor) error
}

Traversing represents a node in a graph.

type TraversingAxis ¶

type TraversingAxis uint

TraversingAxis defines a path of traversal.

const (
	TraverseSelf TraversingAxis = iota
	TraverseRoot
	TraverseChild
	TraverseSibling
	TraverseAncestor
	TraverseDescendant
	TraverseDescendantReverse
	TraverseSelfOrChild
	TraverseSelfOrSibling
	TraverseSelfOrAncestor
	TraverseSelfOrDescendant
	TraverseSelfOrDescendantReverse
	TraverseSelfSiblingOrAncestor
)

type TypeSpec ¶ added in v0.30.25

type TypeSpec struct {
	// contains filtered or unexported fields
}

TypeSpec creates a HandlerInfo using all the exported methods of reflect.Type instance.

func (s TypeSpec) Name() string

func (s TypeSpec) PkgPath() string

func (s TypeSpec) String() string

func (s TypeSpec) Type() reflect.Type

type UnresolvedArgError ¶ added in v0.3.0

type UnresolvedArgError struct {
	Reason error
	// contains filtered or unexported fields
}

UnresolvedArgError reports a failed resolve an arg.

func (e *UnresolvedArgError) Error() string

func (e *UnresolvedArgError) Unwrap() error