miruken

Apr 25, 2024

Changes in this version

+ func ValidEffect(typ reflect.Type) (bool, error)

+ type Effect interface

+ Apply func(HandleContext) (promise.Reflect, error)

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

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

Feb 14, 2024

Changes in this version

+ type Cascade struct

+ 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

Jan 21, 2024

Changes in this version

+ func ValidIntent(typ reflect.Type) (bool, error)

+ type Intent interface

+ Apply func(HandleContext) (promise.Reflect, error)

+ func MakeIntent(intent any, require bool) (Intent, error)

+ func MakeIntents(require bool, intents []any) ([]Intent, error)

Dec 7, 2023

Changes in this version

+ type CurrentHandlerInfoFactoryProvider struct

+ Factory HandlerInfoFactory

+ func (f *CurrentHandlerInfoFactoryProvider) CabBatch() bool

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

+ func (f *CurrentHandlerInfoFactoryProvider) SuppressDispatch()

type Handler

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

Dec 3, 2023

Changes in this version

type Single

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

Nov 29, 2023

Changes in this version

+ var Explicit explicit

Nov 6, 2023

Changes in this version

type HandleContext

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

+ type Key string

+ 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)

Oct 24, 2023

Changes in this version

type LifestyleProvider

+ func (l *LifestyleProvider) Constraints() []Constraint

type Qualifier

+ var UseLifestyle Qualifier[Lifestyle]

Aug 17, 2023

Changes in this version

type ConstructorBinder

+ NewCtorBinding func(typ reflect.Type, ctor *reflect.Method, inits []reflect.Method, ...) (Binding, error)

type CovariantPolicy

+ func (p *CovariantPolicy) NewCtorBinding(typ reflect.Type, ctor *reflect.Method, inits []reflect.Method, ...) (Binding, error)

+ type Init struct

+ type LifestyleInit interface

+ InitLifestyle func(Binding) error

type LifestyleProvider

+ func (l *LifestyleProvider) FiltersAssigned() bool

type SetupBuilder

+ func (s *SetupBuilder) With(values ...any) *SetupBuilder

type Single

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

Aug 8, 2023

Changes in this version

+ type FuncSpec struct

+ func (s FuncSpec) Func() reflect.Value

+ func (s FuncSpec) PkgPath() string

+ func (s FuncSpec) String() string

+ type HandlerInfo struct

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

+ func (h *HandlerInfo) Spec() HandlerSpec

+ type HandlerInfoError struct

+ Cause error

+ Spec HandlerSpec

+ func (e *HandlerInfoError) Error() string

+ func (e *HandlerInfoError) Unwrap() error

+ type HandlerInfoFactory interface

+ Register func(src any) (*HandlerInfo, bool, error)

+ Spec func(src any) HandlerSpec

+ func CurrentHandlerInfoFactory(handler Handler) HandlerInfoFactory

+ type HandlerInfoFactoryBuilder struct

+ func (b *HandlerInfoFactoryBuilder) Build() HandlerInfoFactory

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

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

+ type HandlerInfoObserver interface

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

+ HandlerInfoCreated func(handlerInfo *HandlerInfo)

+ type HandlerInfoObserverFunc func(Policy, *HandlerInfo, Binding)

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

+ type HandlerInfoProvider interface

+ Get func(src any) *HandlerInfo

type MutableHandlers

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

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

type ResolvesBuilder

+ func (b *ResolvesBuilder) New() *Resolves

+ type TypeSpec struct

+ func (s TypeSpec) Name() string

+ func (s TypeSpec) PkgPath() string

+ func (s TypeSpec) String() string

+ func (s TypeSpec) Type() reflect.Type

Jul 20, 2023

Changes in this version

+ func GetOptionsInto(handler Handler, target any) bool

+ type FilterAdapter struct

+ Method string

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

+ type SideEffectAdapter struct

+ Method string

+ func (l SideEffectAdapter) Apply(self SideEffect, ctx HandleContext) (promise.Reflect, error)

Jul 9, 2023

Changes in this version

+ type LateFilter struct

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

+ type LateSideEffect struct

+ func (l LateSideEffect) Apply(sideEffect SideEffect, ctx HandleContext) ([]any, *promise.Promise[[]any], error)

+ type SideEffect interface

+ Apply func(s SideEffect, ctx HandleContext) ([]any, *promise.Promise[[]any], error)

Jul 3, 2023

Changes in this version

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

type CanceledError

+ Cause error

type HandlerDescriptorError

+ Cause error

+ Spec HandlerSpec

type MethodBindingError

+ Cause error

Jun 14, 2023

Changes in this version

+ const FilterStageAuthorization

Jun 10, 2023

Changes in this version

type Constraint

+ Implied func() bool

type HandlerFuncSpec

+ func (s HandlerFuncSpec) PkgPath() string

type HandlerSpec

+ PkgPath func() string

type HandlerTypeSpec

+ func (s HandlerTypeSpec) PkgPath() string

type LifestyleProvider

+ func (l *LifestyleProvider) Implied() bool

type Metadata

+ func (m *Metadata) Implied() bool

type Named

+ func (n *Named) Implied() bool

type Qualifier

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

May 26, 2023

Changes in this version

type Callback

+ Target func() any

+ TargetForWrite func() any

type CallbackBase

+ func (c *CallbackBase) Target() any

+ func (c *CallbackBase) TargetForWrite() any

type CallbackBuilder

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

+ type CanceledError struct

+ Message string

+ Reason error

+ func (e *CanceledError) Error() string

+ func (e *CanceledError) Unwrap() error

Mar 13, 2023

Changes in this version

+ var ErrConstraintNameMissing = errors.New("the Named constraint requires a non-empty `name:[name]` tag")

+ type Constraint interface

+ Required func() bool

+ Satisfies func(required Constraint) bool

+ type ConstraintSource interface

+ Constraints func() []Constraint

type FeatureFunc

+ func FeatureSet(features ...Feature) FeatureFunc

Feb 20, 2023

Changes in this version

type BivariantPolicy

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

type ContravariantPolicy

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

type CovariantPolicy

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

type Policy

+ VariantKey func(key any) (bool, bool)

Feb 12, 2023

Changes in this version

+ var ErrBivMissingCallback = errors.New("bivariant: missing callback argument")

+ var ErrBivMissingReturn = errors.New("bivariant: must have a return value")

+ func Exported(t any) bool

type Binding

+ Async func() bool

+ Exported func() bool

+ LogicalOutputType func() reflect.Type

type BindingBase

+ func (b *BindingBase) Async() bool

+ type BindingObserverFunc func(Policy, *HandlerDescriptor, Binding)

+ func (f BindingObserverFunc) BindingCreated(policy Policy, descriptor *HandlerDescriptor, binding Binding)

+ type BindingParser interface

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

+ type CompositionScope struct

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

type ConstructorBinding

+ func (b *ConstructorBinding) Exported() bool

+ func (b *ConstructorBinding) LogicalOutputType() reflect.Type

type CreatesBuilder

+ func (b *CreatesBuilder) New() *Creates

type FuncBinding

+ func (b *FuncBinding) Exported() bool

+ func (b *FuncBinding) LogicalOutputType() reflect.Type

type HandleResult

+ func (r HandleResult) Stop() bool

type HandlerDescriptor

+ func (d *HandlerDescriptor) HandlerSpec() HandlerSpec

type HandlerDescriptorFactory

+ func CurrentHandlerDescriptorFactory(handler Handler) HandlerDescriptorFactory

+ NewSpec func(spec any) HandlerSpec

+ RegisterSpec func(spec any) (*HandlerDescriptor, bool, error)

type HandlerDescriptorFactoryBuilder

+ func (b *HandlerDescriptorFactoryBuilder) Observers(observers ...HandlerDescriptorObserver) *HandlerDescriptorFactoryBuilder

+ func (b *HandlerDescriptorFactoryBuilder) Parsers(parsers ...BindingParser) *HandlerDescriptorFactoryBuilder

type HandlerDescriptorObserver

+ BindingCreated func(policy Policy, descriptor *HandlerDescriptor, binding Binding)

+ DescriptorCreated func(descriptor *HandlerDescriptor)

type HandlerDescriptorProvider

+ Descriptor func(spec any) *HandlerDescriptor

type HandlesBuilder

+ func (b *HandlesBuilder) New() *Handles

type MethodBinding

+ func (b *MethodBinding) Exported() bool

+ func (b *MethodBinding) LogicalOutputType() reflect.Type

+ type MutableHandlers struct

+ func (m *MutableHandlers) AddHandlers(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) SuppressDispatch()

type ProvidesBuilder

+ func (b *ProvidesBuilder) Build() Provides

+ func (b *ProvidesBuilder) New() *Provides

type SetupBuilder

+ func (s *SetupBuilder) Factory(...) *SetupBuilder

+ func (s *SetupBuilder) Observers(observers ...HandlerDescriptorObserver) *SetupBuilder

+ func (s *SetupBuilder) Parsers(parsers ...BindingParser) *SetupBuilder

+ func (s *SetupBuilder) Tag(tag any) bool

+ type Single struct

+ func (s *Single) Init() error

Jan 27, 2023

Changes in this version

+ func New() *T

+ type BindingBase struct

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

+ func (b *BindingBase) SkipFilters() bool

+ func (b *BindingBase) Strict() bool

type BindingConstraint

+ Satisfies func(required BindingConstraint) bool

+ type BindingConstraintSource interface

+ Constraints func() []BindingConstraint

type CallbackBase

+ func (c *CallbackBase) Constraints() []BindingConstraint

type Creates

+ func (c *Creates) String() string

type Format

+ func (f *Format) Satisfies(required BindingConstraint) bool

type HandleResult

+ func (r HandleResult) Handled() bool

type Handles

+ func (h *Handles) String() string

type Maps

+ func (m *Maps) String() string

type Metadata

+ func (m *Metadata) Required() bool

+ func (m *Metadata) Satisfies(required BindingConstraint) bool

type Named

+ func (n *Named) Satisfies(required BindingConstraint) bool

type Provides

+ func (p *Provides) String() string

type Qualifier

+ func (q Qualifier[T]) Satisfies(required BindingConstraint) bool

+ type ScopedRooted struct

+ func (s *ScopedRooted) Init() error

+ func (s *ScopedRooted) InitWithTag(tag reflect.StructTag) error

Jan 23, 2023

Changes in this version

type SetupBuilder

+ func (s *SetupBuilder) WithoutInference() *SetupBuilder

Jan 22, 2023

Changes in this version

type SetupBuilder

+ func (s *SetupBuilder) Builders(builders ...Builder) *SetupBuilder

+ func (s *SetupBuilder) Context() (*Context, error)

+ func (s *SetupBuilder) ExcludeSpecs(excludes ...Predicate[HandlerSpec]) *SetupBuilder

+ func (s *SetupBuilder) Features(features ...Feature) *SetupBuilder

+ func (s *SetupBuilder) Filters(providers ...FilterProvider) *SetupBuilder

+ func (s *SetupBuilder) Handler() (handler Handler, buildErrors error)

+ func (s *SetupBuilder) Handlers(handlers ...any) *SetupBuilder

+ func (s *SetupBuilder) NoInference() *SetupBuilder

+ func (s *SetupBuilder) Options(options ...any) *SetupBuilder

+ func (s *SetupBuilder) Specs(specs ...any) *SetupBuilder

+ func (s *SetupBuilder) UseHandlerDescriptorFactory(factory HandlerDescriptorFactory) *SetupBuilder

Jan 21, 2023

Changes in this version

type FeatureFunc

+ func Builders(builders ...Builder) FeatureFunc

+ func GroupFeatures(features ...Feature) FeatureFunc

type SetupBuilder

+ func (s *SetupBuilder) AddBuilders(builders ...Builder) *SetupBuilder

Jan 19, 2023

Changes in this version

type Context

+ func SetupContext(features ...Feature) (*Context, error)

type InstallFeature

+ func ExcludeSpecs(rules ...Predicate[HandlerSpec]) InstallFeature

+ func Specs(specs ...any) InstallFeature

Jan 18, 2023

Changes in this version

type BindingConstraint

+ Required func() bool

type BuilderFunc

+ var FromScope = Qualifier[Scoped]{}

+ type ConstructorBinding struct

+ func (b *ConstructorBinding) Invoke(ctx HandleContext, initArgs ...any) ([]any, *promise.Promise[[]any], error)

+ func (b *ConstructorBinding) Key() any

+ func (b *ConstructorBinding) Metadata() []any

+ func (b *ConstructorBinding) SkipFilters() bool

+ func (b *ConstructorBinding) Strict() bool

type Filtered

+ RequireFilters func(providers ...FilterProvider)

type FilteredScope

+ func (f *FilteredScope) RequireFilters(providers ...FilterProvider)

type Format

+ func (f *Format) Required() bool

+ type FuncBinding struct

+ func (b *FuncBinding) Invoke(ctx HandleContext, initArgs ...any) ([]any, *promise.Promise[[]any], error)

+ func (b *FuncBinding) Key() any

+ func (b *FuncBinding) Metadata() []any

+ func (b *FuncBinding) SkipFilters() bool

+ func (b *FuncBinding) Strict() bool

+ type MethodBinding struct

+ func (b *MethodBinding) Invoke(ctx HandleContext, initArgs ...any) ([]any, *promise.Promise[[]any], error)

+ func (b *MethodBinding) Key() any

+ func (b *MethodBinding) Metadata() []any

+ func (b *MethodBinding) Method() reflect.Method

+ func (b *MethodBinding) SkipFilters() bool

+ func (b *MethodBinding) Strict() bool

type Named

+ func (n *Named) Required() bool

type Qualifier

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

type Scoped

+ func (s *Scoped) Constraints() []BindingConstraint

Jan 2, 2023

Changes in this version

+ const FormatDirectionFrom

+ const FormatDirectionNone

+ const FormatDirectionTo

+ const FormatRuleEndsWith

+ const FormatRuleEquals

+ const FormatRulePattern

+ const FormatRuleStartsWith

+ var ErrEmptyFormatIdentifier = errors.New("empty format identifier")

+ var ErrInvalidFormat = errors.New("invalid format tag")

+ func CoerceSlice(slice reflect.Value, elemTyp reflect.Type) (reflect.Value, bool)

+ func CreateKey(handler Handler, key any, constraints ...any) (t T, tp *promise.Promise[T], err error)

+ func MapKey(handler Handler, key any, constraints ...any) (t T, tp *promise.Promise[T], err error)

+ func ResolveKey(handler Handler, key any, constraints ...any) (t T, tp *promise.Promise[T], err error)

type Callback

+ Metadata func() *BindingMetadata

type CallbackBase

+ func (c *CallbackBase) Metadata() *BindingMetadata

type CallbackBuilder

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

type CancelledError

+ Message string

+ Reason error

+ type ConstraintBuilderFunc func(*ConstraintBuilder)

type CreatesBuilder

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

type Format

+ func From(format string) *Format

+ func To(format string) *Format

+ func (f *Format) Direction() FormatDirection

+ func (f *Format) Identifier() string

+ func (f *Format) Rule() FormatRule

+ type FormatDirection uint8

+ type FormatRule uint8

+ type Late struct

+ Value any

type MapsBuilder

+ func (b *MapsBuilder) WithKey(key any) *MapsBuilder

+ type Option struct

+ func Set(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 Provides

+ func (p *Provides) Owner() any

type ProvidesBuilder

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

type SetupBuilder

+ func (s *SetupBuilder) AddBuilder(builders ...Builder) *SetupBuilder

+ func (s *SetupBuilder) RequireFilters(providers ...FilterProvider) *SetupBuilder

+ type Timespan time.Duration

+ func (t Timespan) Format(format string) string

Nov 1, 2022

Changes in this version

+ var ErrBiMissingCallback = errors.New("bivariant: missing callback argument")

+ var ErrBiMissingReturn = errors.New("bivariant: must have a return value")

+ var ErrConMissingCallback = errors.New("contravariant: missing callback argument")

+ var ErrConResultsExceeded = errors.New("contravariant: cannot accept more than 2 results")

+ var ErrCovMissingReturn = errors.New("covariant: must have a return value")

+ var ErrCovResultsExceeded = errors.New("covariant: cannot accept more than 2 results")

+ var ErrFormatMissing = errors.New("the Format constraint requires a non-empty `as:format` tag")

+ var ErrNameMissing = errors.New("the Named constraint requires a non-empty `name:[name]` tag")

+ func Batch(handler Handler, configure func(Handler), tags ...any) *promise.Promise[[]any]

+ func BatchAsync(handler Handler, configure func(Handler) *promise.Promise[T], tags ...any) *promise.Promise[[]any]

+ func BatchTag(handler Handler, configure func(Handler)) *promise.Promise[[]any]

+ func BatchTagAsync(handler Handler, configure func(Handler) *promise.Promise[T]) *promise.Promise[[]any]

+ func CoerceResult(callback Callback, target *T) (t T, tp *promise.Promise[T], _ error)

+ func CoerceResults(callback Callback, target *[]T) (t []T, tp *promise.Promise[[]T], _ error)

+ func Command(handler Handler, callback any) (pv *promise.Promise[Void], err error)

+ func CommandAll(handler Handler, callback any) (pv *promise.Promise[Void], err error)

+ func CompleteResult(callback Callback) (*promise.Promise[Void], error)

+ func CompleteResults(callback Callback) (*promise.Promise[Void], error)

+ func Execute(handler Handler, callback any) (t T, tp *promise.Promise[T], err error)

+ func ExecuteAll(handler Handler, callback any) (t []T, tp *promise.Promise[[]T], err error)

+ func GetBatch(handler Handler, tags ...any) TB

+ func ValidateROutput(installer *ValidationInstaller)

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

+ type Batched struct

+ Callback Callback

+ Source T

+ type BindingGroup struct

+ func (d BindingGroup) DefinesBindingGroup()

type BivariantPolicy

+ func (p *BivariantPolicy) Strict() bool

type BuilderFunc

+ var NoBatch BuilderFunc = func(handler Handler) Handler { ... }

type CallbackBase

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

type CallbackSemantics

+ func (c *CallbackSemantics) CanBatch() bool

+ type CancelledError struct

+ func NewCancelledError(message string, reason error) *CancelledError

+ func (e *CancelledError) Error() string

+ func (e *CancelledError) Unwrap() error

type Context

+ func (m *Context) Handlers() []any

type ContravariantPolicy

+ func (p *ContravariantPolicy) Strict() bool

type CovariantPolicy

+ func (p *CovariantPolicy) Strict() bool

type DependencyArg

+ func (d DependencyArg) Promise() bool

type Feature

+ func ValidationFeature(config ...func(installer *ValidationInstaller)) Feature

type Handles

+ func (h *Handles) CanBatch() bool

type Next

+ 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() ([]any, *promise.Promise[[]any], error)

+ func (n Next) PipeAwait() []any

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

+ func (n Next) PipeComposerAwait(composer Handler) []any

type NotHandledError

+ func NewNotHandledError(callback any) *NotHandledError

type Policy

+ Strict func() bool

type RejectedError

+ func NewRejectedError(callback any) *RejectedError

+ type Resolves struct

+ func (r *Resolves) Callback() Callback

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

+ func (r *Resolves) Succeeded() bool

+ type ResolvesBuilder struct

+ func (b *ResolvesBuilder) NewResolves() *Resolves

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

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

type Trampoline

+ func (t *Trampoline) CanBatch() bool

type ValidateProvider

+ func (v *ValidateProvider) AppliesTo(callback Callback) bool

type ValidationInstaller

+ func (v *ValidationInstaller) ValidateOutput()

+ type Void = struct

May 28, 2022

Changes in this version

type DependencyArg

+ func (d DependencyArg) Metadata() []any

May 28, 2022

Changes in this version

+ var AncestorAxis = Axis(TraverseAncestor)

+ var BestEffort = CallWith(SemanticBestEffort)

+ var Broadcast = CallWith(SemanticBroadcast)

+ var ChildAxis = Axis(TraverseChild)

+ var DescendantAxis = Axis(TraverseDescendant)

+ var DescendantReverseAxis = Axis(TraverseDescendantReverse)

+ var Notify = CallWith(SemanticNotify)

+ var Publish = ComposeBuilders(SelfOrDescendantAxis, Notify)

+ var RootAxis = Axis(TraverseRoot)

+ var SelfAxis = Axis(TraverseSelf)

+ var SelfOrAncestorAxis = Axis(TraverseSelfOrAncestor)

+ var SelfOrChildAxis = Axis(TraverseSelfOrChild)

+ var SelfOrDescendantAxis = Axis(TraverseSelfOrDescendant)

+ var SelfOrDescendantReverseAxis = Axis(TraverseSelfOrDescendant)

+ var SelfOrSiblingAxis = Axis(TraverseSelfOrSibling)

+ var SelfSiblingOrAncestorAxis = Axis(TraverseSelfSiblingOrAncestor)

+ var SiblingAxis = Axis(TraverseSibling)

type Binding

+ Metadata func() []any

type Builder

+ func CallWith(semantics SemanticFlags) Builder

+ func RequireFilters(filters ...Filter) Builder

+ func UseFilters(filters ...Filter) Builder

+ BuildUp func(handler Handler) Handler

type BuilderFunc

+ var PublishFromRoot BuilderFunc = func(handler Handler) Handler { ... }

+ func Axis(axis TraversingAxis) BuilderFunc

+ func Options(options any) BuilderFunc

+ func ProvideFilters(providers ...FilterProvider) BuilderFunc

+ func Reentrant(filter FilterFunc) BuilderFunc

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

type Callback

+ ResultCount func() int

type CallbackBase

+ func (c *CallbackBase) ResultCount() int

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

+ type ConfigureHandlerDescriptorFactory func(builder *HandlerDescriptorFactoryBuilder)

+ func (f ConfigureHandlerDescriptorFactory) Configure(builder *HandlerDescriptorFactoryBuilder)

type FilterFunc

+ func (f FilterFunc) BuildUp(handler Handler) Handler

type HandleResult

+ func (r HandleResult) AndBlock(other HandleResult) HandleResult

+ func (r HandleResult) OrBlock(block HandleResultBlock) HandleResult

type Handler

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

+ type HandlerDescriptorFactoryBuilder struct

+ func (b *HandlerDescriptorFactoryBuilder) AddBindingBuilders(bindings ...bindingBuilder) *HandlerDescriptorFactoryBuilder

+ func (b *HandlerDescriptorFactoryBuilder) Build() HandlerDescriptorFactory

+ func (b *HandlerDescriptorFactoryBuilder) SetObserver(observer HandlerDescriptorObserver) *HandlerDescriptorFactoryBuilder

+ type HandlerDescriptorFactoryOption interface

+ Configure func(builder *HandlerDescriptorFactoryBuilder)

+ type HandlerDescriptorObserver interface

+ NotifyHandlerBinding func(descriptor *HandlerDescriptor, binding Binding)

type HandlerDescriptorVisitorFunc

+ func (f HandlerDescriptorVisitorFunc) NotifyHandlerBinding(descriptor *HandlerDescriptor, binding Binding)

+ type InstallFeature func(setup *SetupBuilder) error

+ var NoInference InstallFeature = func(setup *SetupBuilder) error { ... }

+ func HandlerSpecs(specs ...any) InstallFeature

+ func Handlers(handlers ...any) InstallFeature

+ func UseHandlerDescriptorFactory(factory HandlerDescriptorFactory) InstallFeature

+ func (f InstallFeature) Install(setup *SetupBuilder) error

+ type ProceedFunc func() HandleResult

May 17, 2022

Changes in this version

+ func MapInto(handler Handler, source any, target *T, format ...any) error

+ func WithConstraint(constraint BindingConstraint) func(*ConstraintBuilder)

+ func WithConstraintProvider(provider T) func(*ConstraintBuilder)

+ func WithMetadata(metadata BindingMetadata) func(*ConstraintBuilder)

+ func WithName(name string) func(*ConstraintBuilder)

+ func WithQualifier() func(*ConstraintBuilder)

+ type ConstraintInitialize interface

+ Init func() error

type HandleContext

+ func (h HandleContext) Handler() any

type Qualifier

+ func (q Qualifier[T]) Matches(metadata *BindingMetadata) bool

+ func (q Qualifier[T]) Require(metadata *BindingMetadata)

May 15, 2022

Changes in this version

type Callback

+ Source func() any

+ type CallbackArg struct

type CallbackBase

+ func (c *CallbackBase) Source() any

type HandleContext

+ Greedy func() bool

+ type HandlerFuncSpec struct

+ func (s HandlerFuncSpec) Func() reflect.Value

+ func (s HandlerFuncSpec) String() string

type Handles

+ func (h *Handles) Source() any

type Trampoline

+ func (t *Trampoline) Source() any

type Validates

+ func (v *Validates) Source() any

May 12, 2022

Changes in this version

+ func MakeCaller(fun any) (func(Handler) []reflect.Value, error)

+ func WithoutInference(setup *SetupBuilder)

type BivariantPolicy

+ func (p *BivariantPolicy) NewFuncBinding(fun reflect.Value, spec *policySpec) (Binding, error)

type Context

+ func (m *Context) SuppressDispatch()

type ContravariantPolicy

+ func (p *ContravariantPolicy) NewFuncBinding(fun reflect.Value, spec *policySpec) (Binding, error)

type CovariantPolicy

+ func (p *CovariantPolicy) NewFuncBinding(fun reflect.Value, spec *policySpec) (Binding, error)

+ type Feature interface

+ Install func(setup *SetupBuilder)

+ func ExcludeHandlerSpecs(rules ...Predicate[HandlerSpec]) Feature

+ func WithHandlerSpecs(specs ...any) Feature

+ type FeatureFunc func(setup *SetupBuilder)

+ func (f FeatureFunc) Install(setup *SetupBuilder)

+ type FuncBinder interface

+ NewFuncBinding func(fun reflect.Value, spec *policySpec) (Binding, error)

+ type FuncBindingError struct

+ func (e FuncBindingError) Error() string

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

+ func (e FuncBindingError) Unwrap() error

type Handler

+ func Setup(features ...Feature) Handler

type HandlerDescriptorError

+ func (e *HandlerDescriptorError) HandlerSpec() HandlerSpec

type HandlerDescriptorFactory

+ MakeHandlerSpec func(spec any) HandlerSpec

+ RegisterHandler func(spec any) (*HandlerDescriptor, bool, error)

type HandlerDescriptorProvider

+ DescriptorOf func(spec any) *HandlerDescriptor

+ type HandlerSpec interface

+ type HandlerTypeSpec struct

+ func (s HandlerTypeSpec) Name() string

+ func (s HandlerTypeSpec) String() string

+ func (s HandlerTypeSpec) Type() reflect.Type

type ResolvingBuilder

+ func (b *ResolvingBuilder) WithGreedy(greedy bool) *ResolvingBuilder

+ type SetupBuilder struct

+ func (s *SetupBuilder) AddFilters(providers ...FilterProvider) *SetupBuilder

+ func (s *SetupBuilder) AddHandlers(handlers ...any) *SetupBuilder

+ func (s *SetupBuilder) Build() Handler

+ func (s *SetupBuilder) CanInstall(tag any) bool

+ func (s *SetupBuilder) DisableInference()

+ func (s *SetupBuilder) Exclude(excludes ...Predicate[HandlerSpec]) *SetupBuilder

+ func (s *SetupBuilder) Install(feature Feature) *SetupBuilder

+ func (s *SetupBuilder) RegisterHandlers(specs ...any) *SetupBuilder

+ func (s *SetupBuilder) SetHandlerDescriptorFactory(factory HandlerDescriptorFactory) *SetupBuilder

+ type UnresolvedArgError struct

+ Reason error

+ func (e UnresolvedArgError) Error() string

+ func (e UnresolvedArgError) Unwrap() error

May 1, 2022

Changes in this version

+ const FilterStage

+ const FilterStageLogging

+ const FilterStageValidation

+ const FilterStateAuthorization

+ var DisableInference = InstallerFunc(func(registration *Registration) { ... })

+ var Handled = HandleResult

+ var HandledAndStop = HandleResult

+ var NotHandled = HandleResult

+ var NotHandledAndStop = HandleResult

+ var WithAncestor = WithAxis(TraverseAncestor)

+ var WithBestEffort = WithCallSemantics(SemanticBestEffort)

+ var WithBroadcast = WithCallSemantics(SemanticBroadcast)

+ var WithChild = WithAxis(TraverseChild)

+ var WithDescendant = WithAxis(TraverseDescendant)

+ var WithDescendantReverse = WithAxis(TraverseDescendantReverse)

+ var WithNotify = WithCallSemantics(SemanticNotify)

+ var WithPublish = ComposeBuilders(WithSelfOrDescendant, WithNotify)

+ var WithRoot = WithAxis(TraverseRoot)

+ var WithSelf = WithAxis(TraverseSelf)

+ var WithSelfOrAncestor = WithAxis(TraverseSelfOrAncestor)

+ var WithSelfOrChild = WithAxis(TraverseSelfOrChild)

+ var WithSelfOrDescendant = WithAxis(TraverseSelfOrDescendant)

+ var WithSelfOrDescendantReverse = WithAxis(TraverseSelfOrDescendant)

+ var WithSelfOrSibling = WithAxis(TraverseSelfOrSibling)

+ var WithSelfSiblingOrAncestor = WithAxis(TraverseSelfSiblingOrAncestor)

+ var WithSibling = WithAxis(TraverseSibling)

+ var WithStrict = WithCallSemantics(SemanticStrict)

+ func CopyIndirect(src any, target any)

+ func CopySliceIndirect(src []any, target any)

+ func Create(handler Handler, target any) error

+ func CreateAll(handler Handler, target any) error

+ func DynNext(filter Filter, next Next, context HandleContext, provider FilterProvider) (results []any, invalid error)

+ func FilterSlice(s []T, f func(T) bool) []T

+ func GetOptions(handler Handler, target any) bool

+ func Invoke(handler Handler, callback any, target any) error

+ func InvokeAll(handler Handler, callback any, target any) error

+ func IsNil(val any) bool

+ func IsStruct(val any) bool

+ func Map(handler Handler, source any, target any, format ...any) error

+ func MapAll(handler Handler, source any, target any, format ...any) error

+ func MapSlice(s []T, f func(T) U) []U

+ func MergeOptions(from, into any) bool

+ func ReduceSlice(s []T, init U, f func(U, T) U) U

+ func Resolve(handler Handler, target any, constraints ...func(*ConstraintBuilder)) error

+ func ResolveAll(handler Handler, target any, constraints ...func(*ConstraintBuilder)) error

+ func TargetSliceValue(target any) reflect.Value

+ func TargetValue(target any) reflect.Value

+ func TraverseAxis(node Traversing, axis TraversingAxis, visitor TraversalVisitor) error

+ func TraverseLevelOrder(node Traversing, visitor TraversalVisitor) error

+ func TraversePostOrder(node Traversing, visitor TraversalVisitor) error

+ func TraversePreOrder(node Traversing, visitor TraversalVisitor) error

+ func TraverseReverseLevelOrder(node Traversing, visitor TraversalVisitor) error

+ func TypeOf() reflect.Type

+ func ValidateResults(installer *ValidationInstaller)

+ func ValueAs(v reflect.Value) (r T)

+ type AcceptResultFunc func(result any, greedy bool, composer Handler) HandleResult

+ type Binding interface

+ Invoke func(ctx HandleContext, explicitArgs ...any) (results []any, err error)

+ Key func() any

+ SkipFilters func() bool

+ Strict func() bool

+ type BindingConstraint interface

+ Matches func(metadata *BindingMetadata) bool

+ Require func(metadata *BindingMetadata)

+ type BindingMetadata struct

+ func ApplyConstraints(scope BindingScope, constraints ...func(*ConstraintBuilder)) *BindingMetadata

+ func (b *BindingMetadata) Get(key any) (any, bool)

+ func (b *BindingMetadata) Has(key any) bool

+ func (b *BindingMetadata) IsEmpty() bool

+ func (b *BindingMetadata) MergeInto(other *BindingMetadata)

+ func (b *BindingMetadata) Name() string

+ func (b *BindingMetadata) Set(key any, val any)

+ func (b *BindingMetadata) SetName(name string)

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

+ type BindingScope interface

+ Metadata func() *BindingMetadata

+ type BivariantPolicy struct

+ func (p *BivariantPolicy) AcceptResults(results []any) (result any, accepted HandleResult)

+ func (p *BivariantPolicy) IsVariantKey(key any) (variant bool, unknown bool)

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

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

+ func (p *BivariantPolicy) NewMethodBinding(method reflect.Method, spec *policySpec) (binding Binding, invalid error)

+ type Builder interface

+ Build func(Handler) Handler

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

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

+ func With(values ...any) Builder

+ func WithAxis(axis TraversingAxis) Builder

+ func WithCallSemantics(semantics SemanticFlags) Builder

+ func WithFilter(filter FilterFunc, reentrant bool) Builder

+ func WithFilterProviders(providers ...FilterProvider) Builder

+ func WithFilters(filters ...Filter) Builder

+ func WithOptions(options any) Builder

+ func WithRequiredFilters(filters ...Filter) Builder

+ type BuilderFunc func(Handler) Handler

+ var DisableFilters BuilderFunc = func(handler Handler) Handler { ... }

+ var EnableFilters BuilderFunc = func(handler Handler) Handler { ... }

+ var WithPublishFromRoot BuilderFunc = func(handler Handler) Handler { ... }

+ func (f BuilderFunc) Build(handler Handler) Handler

+ type Callback interface

+ Key func() any

+ Many func() bool

+ Policy func() Policy

+ ReceiveResult func(result any, strict bool, greedy bool, composer Handler) HandleResult

+ Result func() any

+ ResultType func() reflect.Type

+ SetResult func(result any)

+ type CallbackBase struct

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

+ func (c *CallbackBase) CopyResult(target any)

+ func (c *CallbackBase) Many() bool

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

+ func (c *CallbackBase) Result() any

+ func (c *CallbackBase) ResultType() reflect.Type

+ func (c *CallbackBase) SetResult(result any)

+ type CallbackBuilder struct

+ func (b *CallbackBuilder) CallbackBase() CallbackBase

+ func (b *CallbackBuilder) WithAcceptResult(accept AcceptResultFunc) *CallbackBuilder

+ func (b *CallbackBuilder) WithMany() *CallbackBuilder

+ type CallbackDispatcher interface

+ Dispatch func(handler any, greedy bool, composer Handler) HandleResult

+ type CallbackGuard interface

+ CanDispatch func(handler any, binding Binding) (reset func(), approved bool)

+ type CallbackSemantics struct

+ func GetSemantics(handler Handler) *CallbackSemantics

+ 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 ChildContextEndedObserver interface

+ ChildContextEnded func(childCtx *Context, reason any)

+ type ChildContextEndedObserverFunc func(ctx *Context, reason any)

+ func (f ChildContextEndedObserverFunc) ChildContextEnded(ctx *Context, reason any)

+ type ChildContextEndingObserver interface

+ ChildContextEnding func(childCtx *Context, reason any)

+ type ChildContextEndingObserverFunc func(ctx *Context, reason any)

+ func (f ChildContextEndingObserverFunc) ChildContextEnding(ctx *Context, reason any)

+ type CompletePipelineFunc func(HandleContext) ([]any, error)

+ type Composition struct

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

+ type ConstraintBuilder struct

+ func (b *ConstraintBuilder) Metadata() (metadata *BindingMetadata)

+ func (b *ConstraintBuilder) Named(name string) *ConstraintBuilder

+ func (b *ConstraintBuilder) WithConstraint(constraint BindingConstraint) *ConstraintBuilder

+ func (b *ConstraintBuilder) WithMetadata(metadata BindingMetadata) *ConstraintBuilder

+ type ConstraintProvider struct

+ func (c *ConstraintProvider) AppliesTo(callback Callback) bool

+ func (c *ConstraintProvider) Constraints() []BindingConstraint

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

+ func (c *ConstraintProvider) Required() bool

+ type ConstructorBinder interface

+ NewConstructorBinding func(handlerType reflect.Type, constructor *reflect.Method, spec *policySpec) (binding Binding, invalid error)

+ type Context struct

+ func NewContext(handlers ...any) *Context

+ func (c *Context) Children() []Traversing

+ func (c *Context) Dispose()

+ func (c *Context) End(reason any)

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

+ func (c *Context) HandleAxis(axis TraversingAxis, callback any, greedy bool, composer Handler) HandleResult

+ func (c *Context) HasChildren() bool

+ func (c *Context) NewChild() *Context

+ func (c *Context) Observe(observer ContextObserver) Disposable

+ func (c *Context) Parent() Traversing

+ func (c *Context) Root() *Context

+ func (c *Context) State() ContextState

+ func (c *Context) Store(values ...any) *Context

+ func (c *Context) Traverse(axis TraversingAxis, visitor TraversalVisitor) error

+ func (c *Context) Unwind(reason any) *Context

+ func (c *Context) UnwindToRoot(reason any) *Context

+ func (m *Context) AddHandlers(handlers ...any) *mutableHandlers

+ func (m *Context) InsertHandlers(index int, handlers ...any) *mutableHandlers

+ func (m *Context) RemoveHandlers(handlers ...any) *mutableHandlers

+ type ContextChangedObserver interface

+ ContextChanged func(contextual Contextual, oldCtx *Context, newCtx *Context)

+ type ContextChangedObserverFunc func(contextual Contextual, oldCtx *Context, newCtx *Context)

+ func (f ContextChangedObserverFunc) ContextChanged(contextual Contextual, oldCtx *Context, newCtx *Context)

+ type ContextChangingObserver interface

+ ContextChanging func(contextual Contextual, oldCtx *Context, newCtx **Context)

+ type ContextChangingObserverFunc func(contextual Contextual, oldCtx *Context, newCtx **Context)

+ func (f ContextChangingObserverFunc) ContextChanging(contextual Contextual, oldCtx *Context, newCtx **Context)

+ type ContextEndedObserver interface

+ ContextEnded func(ctx *Context, reason any)

+ type ContextEndedObserverFunc func(ctx *Context, reason any)

+ func (f ContextEndedObserverFunc) ContextEnded(ctx *Context, reason any)

+ type ContextEndingObserver interface

+ ContextEnding func(ctx *Context, reason any)

+ type ContextEndingObserverFunc func(ctx *Context, reason any)

+ func (f ContextEndingObserverFunc) ContextEnding(ctx *Context, reason any)

+ type ContextObserver = interface

+ type ContextReason uint

+ const ContextAlreadyEnded

+ const ContextDisposed

+ const ContextUnwinded

+ type ContextState uint

+ const ContextActive

+ const ContextEnded

+ const ContextEnding

+ type Contextual interface

+ Context func() *Context

+ Observe func(observer ContextObserver) Disposable

+ SetContext func(ctx *Context)

+ type ContextualBase struct

+ func (c *ContextualBase) ChangeContext(contextual Contextual, ctx *Context)

+ func (c *ContextualBase) Context() *Context

+ func (c *ContextualBase) EndContext()

+ func (c *ContextualBase) Observe(observer ContextObserver) Disposable

+ type ContravariantPolicy struct

+ func (p *ContravariantPolicy) AcceptResults(results []any) (result any, accepted HandleResult)

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

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

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

+ func (p *ContravariantPolicy) NewMethodBinding(method reflect.Method, spec *policySpec) (binding Binding, invalid error)

+ type CovariantPolicy struct

+ func (p *CovariantPolicy) AcceptResults(results []any) (result any, accepted HandleResult)

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

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

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

+ func (p *CovariantPolicy) NewMethodBinding(method reflect.Method, spec *policySpec) (binding Binding, invalid error)

+ type Creates struct

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

+ func (c *Creates) Key() any

+ func (c *Creates) Policy() Policy

+ type CreatesBuilder struct

+ func (b *CreatesBuilder) NewCreation() *Creates

+ func (b *CreatesBuilder) WithType(typ reflect.Type) *CreatesBuilder

+ type DependencyArg struct

+ func (d DependencyArg) Optional() bool

+ func (d DependencyArg) Strict() bool

+ type DependencyResolver interface

+ Resolve func(typ reflect.Type, rawCallback Callback, dep DependencyArg, handler Handler) (reflect.Value, error)

+ type DiKey struct

+ In any

+ Out any

+ type Disposable interface

+ Dispose func()

+ type DisposableFunc func()

+ func (f DisposableFunc) Dispose()

+ type Filter interface

+ Next func(next Next, context HandleContext, provider FilterProvider) ([]any, error)

+ Order func() int

+ type FilterFunc = func(callback any, composer Handler, proceed func() HandleResult) HandleResult

+ type FilterInstanceProvider struct

+ 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 struct

+ Providers []FilterProvider

+ SkipFilters OptionBool

+ type FilterProvider interface

+ Filters func(binding Binding, callback any, composer Handler) ([]Filter, error)

+ Required func() bool

+ type FilterSpecProvider struct

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

+ func (f *FilterSpecProvider) Required() bool

+ type Filtered interface

+ AddFilters func(providers ...FilterProvider)

+ Filters func() []FilterProvider

+ RemoveAllFilters func()

+ RemoveFilters func(providers ...FilterProvider)

+ type FilteredScope struct

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

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

+ func (f *FilteredScope) RemoveAllFilters()

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

+ type Format struct

+ func (f *Format) InitWithTag(tag reflect.StructTag) error

+ func (f *Format) Matches(metadata *BindingMetadata) bool

+ func (f *Format) Merge(constraint BindingConstraint) bool

+ func (f *Format) Require(metadata *BindingMetadata)

+ type FromOptions struct

+ func (o FromOptions) Resolve(typ reflect.Type, rawCallback Callback, dep DependencyArg, handler Handler) (options reflect.Value, err error)

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

+ type Group struct

+ func (g *Group) InitWithTag(tag reflect.StructTag) error

+ func (g *Group) Matches(metadata *BindingMetadata) bool

+ func (g *Group) Merge(constraint BindingConstraint) bool

+ func (g *Group) Require(metadata *BindingMetadata)

+ type HandleContext struct

+ func (h HandleContext) Binding() Binding

+ func (h HandleContext) Callback() any

+ func (h HandleContext) Composer() Handler

+ func (h HandleContext) RawCallback() Callback

+ type HandleResult struct

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

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

+ func (r HandleResult) And(other HandleResult) HandleResult

+ func (r HandleResult) Error() error

+ func (r HandleResult) IsError() bool

+ func (r HandleResult) IsHandled() bool

+ func (r HandleResult) Or(other HandleResult) 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) ShouldStop() 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 func(HandleResult) HandleResult

+ type Handler interface

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

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

+ func Build(handler Handler, builders ...Builder) Handler

+ func NewProvider(value any) Handler

+ func ToHandler(handler any) Handler

+ type HandlerAxis interface

+ HandleAxis func(axis TraversingAxis, callback any, greedy bool, composer Handler) HandleResult

+ type HandlerDescriptor struct

+ func (d *HandlerDescriptor) Dispatch(policy Policy, handler any, callback any, rawCallback Callback, greedy bool, ...) (result HandleResult)

+ type HandlerDescriptorError struct

+ HandlerType reflect.Type

+ Reason error

+ func (e *HandlerDescriptorError) Error() string

+ func (e *HandlerDescriptorError) Unwrap() error

+ type HandlerDescriptorFactory interface

+ RegisterHandlerType func(handlerType reflect.Type) (*HandlerDescriptor, bool, error)

+ func GetHandlerDescriptorFactory(handler Handler) HandlerDescriptorFactory

+ func NewMutableHandlerDescriptorFactory(opts ...MutableHandlerDescriptorFactoryOption) HandlerDescriptorFactory

+ type HandlerDescriptorProvider interface

+ HandlerDescriptorOf func(handler reflect.Type) (*HandlerDescriptor, error)

+ type HandlerDescriptorVisitor interface

+ VisitHandlerBinding func(descriptor *HandlerDescriptor, binding Binding)

+ type HandlerDescriptorVisitorFunc func(*HandlerDescriptor, Binding)

+ func (f HandlerDescriptorVisitorFunc) VisitHandlerBinding(descriptor *HandlerDescriptor, binding Binding)

+ type Handles struct

+ func (h *Handles) Callback() any

+ 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

+ type HandlesBuilder struct

+ func (b *HandlesBuilder) NewHandles() *Handles

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

+ type Installer interface

+ Install func(registration *Registration)

+ func ExcludeHandlerTypes(filter ...Predicate[reflect.Type]) Installer

+ func WithHandlerDescriptorFactory(factory HandlerDescriptorFactory) Installer

+ func WithHandlerTypes(types ...reflect.Type) Installer

+ func WithHandlers(handlers ...any) Installer

+ func WithValidation(config ...func(installer *ValidationInstaller)) Installer

+ type InstallerFunc func(registration *Registration)

+ func (f InstallerFunc) Install(registration *Registration)

+ type JsonMapper struct

+ func (m *JsonMapper) FromJson(_ ..., jsonString string, maps *Maps) (any, error)

+ func (m *JsonMapper) FromJsonStream(_ ..., stream io.Reader, maps *Maps) (any, error)

+ func (m *JsonMapper) ToJson(_ ..., maps *Maps, _ ..., options JsonOptions) (js string, err error)

+ func (m *JsonMapper) ToJsonStream(_ ..., maps *Maps, _ ..., options JsonOptions) (stream io.Writer, err error)

+ type JsonOptions struct

+ Indent string

+ Prefix string

+ type KeyValues map[any]any

+ type Lifestyle struct

+ func (l *Lifestyle) Order() int

+ type LifestyleProvider struct

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

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

+ func (l *LifestyleProvider) Required() bool

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

+ type Maps struct

+ func (m *Maps) Dispatch(handler any, greedy bool, composer Handler) HandleResult

+ func (m *Maps) Format() any

+ func (m *Maps) Key() any

+ func (m *Maps) Metadata() *BindingMetadata

+ func (m *Maps) Policy() Policy

+ func (m *Maps) Source() any

+ func (m *Maps) Target() any

+ type MapsBuilder struct

+ func (b *MapsBuilder) FromSource(source any) *MapsBuilder

+ func (b *MapsBuilder) NewMaps() *Maps

+ func (b *MapsBuilder) ToTarget(target any) *MapsBuilder

+ func (b *MapsBuilder) WithFormat(format any) *MapsBuilder

+ type Metadata struct

+ func (m *Metadata) InitWithMetadata(metadata KeyValues) error

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

+ func (m *Metadata) Matches(metadata *BindingMetadata) bool

+ func (m *Metadata) Require(metadata *BindingMetadata)

+ type MethodBinder interface

+ NewMethodBinding func(method reflect.Method, spec *policySpec) (binding Binding, invalid error)

+ type MethodBindingError struct

+ Method reflect.Method

+ Reason error

+ func (e MethodBindingError) Error() string

+ func (e MethodBindingError) Unwrap() error

+ type MutableHandlerDescriptorFactoryOption interface

+ func WithHandlerDescriptorVisitor(visitor HandlerDescriptorVisitor) MutableHandlerDescriptorFactoryOption

+ type Named struct

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

+ func (n *Named) Matches(metadata *BindingMetadata) bool

+ func (n *Named) Name() string

+ func (n *Named) Require(metadata *BindingMetadata)

+ type Next func(composer Handler, proceed bool) ([]any, error)

+ func (n Next) Abort() ([]any, error)

+ func (n Next) Filter() ([]any, error)

+ func (n Next) WithComposer(composer Handler) ([]any, error)

+ type NotHandledError struct

+ func (e NotHandledError) Callback() any

+ func (e NotHandledError) Error() string

+ type OptionBool byte

+ const OptionFalse

+ const OptionNone

+ const OptionTrue

+ func (b OptionBool) Bool() bool

+ type Optional struct

+ type Policy interface

+ AcceptResults func(results []any) (any, HandleResult)

+ IsVariantKey func(key any) (bool, bool)

+ Less func(binding, otherBinding Binding) bool

+ MatchesKey func(key, otherKey any, strict bool) (bool, bool)

+ type PolicyDispatch interface

+ DispatchPolicy func(policy Policy, callback any, rawCallback Callback, greedy bool, ...) HandleResult

+ type Predicate func(T) bool

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

+ type Provides struct

+ 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) Metadata() *BindingMetadata

+ func (p *Provides) Parent() *Provides

+ func (p *Provides) Policy() Policy

+ func (p *Provides) ReceiveResult(result any, strict bool, greedy bool, composer Handler) HandleResult

+ func (p *Provides) Resolve(handler Handler) (any, error)

+ type ProvidesBuilder struct

+ func (b *ProvidesBuilder) NewProvides() *Provides

+ func (b *ProvidesBuilder) Provides() Provides

+ func (b *ProvidesBuilder) WithConstraints(constraints ...func(*ConstraintBuilder)) *ProvidesBuilder

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

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

+ type Qualifier struct

+ func (q Qualifier) MatchesQualifier(qualifier any, metadata *BindingMetadata) bool

+ func (q Qualifier) RequireQualifier(qualifier any, metadata *BindingMetadata)

+ type Registration struct

+ func NewRegistration(installers ...Installer) *Registration

+ func (r *Registration) AddFilters(providers ...FilterProvider) *Registration

+ func (r *Registration) AddHandlerTypes(handlerTypes ...reflect.Type) *Registration

+ func (r *Registration) AddHandlers(handlers ...any) *Registration

+ func (r *Registration) Build() Handler

+ func (r *Registration) CanInstall(tag any) bool

+ func (r *Registration) DisableInference()

+ func (r *Registration) ExcludeHandlerTypes(excludes ...Predicate[reflect.Type]) *Registration

+ func (r *Registration) Install(installer Installer) *Registration

+ func (r *Registration) SetHandlerDescriptorFactory(factory HandlerDescriptorFactory) *Registration

+ type RejectedError struct

+ func (e RejectedError) Callback() any

+ func (e RejectedError) Error() string

+ type Resolving struct

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

+ func (r *Resolving) Succeeded() bool

+ type ResolvingBuilder struct

+ func (b *ResolvingBuilder) NewResolving() *Resolving

+ func (b *ResolvingBuilder) WithCallback(callback Callback) *ResolvingBuilder

+ type Scoped struct

+ func (s *Scoped) Constraint() BindingConstraint

+ func (s *Scoped) Init() error

+ func (s *Scoped) InitWithTag(tag reflect.StructTag) error

+ type ScopedQualifier struct

+ func (s ScopedQualifier) Matches(metadata *BindingMetadata) bool

+ func (s ScopedQualifier) Require(metadata *BindingMetadata)

+ type SemanticFlags uint8

+ const SemanticBestEffort

+ const SemanticBroadcast

+ const SemanticNone

+ const SemanticNotify

+ const SemanticStrict

+ type Singleton struct

+ func (s *Singleton) Init() error

+ type SkipFilters struct

+ type Strict struct

+ type SuppressDispatch interface

+ type Trampoline struct

+ func (t *Trampoline) Callback() any

+ 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() any

+ func (t *Trampoline) ResultType() reflect.Type

+ func (t *Trampoline) SetResult(result any)

+ type TraversalCircularityError struct

+ func (e TraversalCircularityError) Culprit() Traversing

+ func (e TraversalCircularityError) Error() string

+ type TraversalVisitor interface

+ VisitTraversal func(node Traversing) (stop bool, err error)

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

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

+ type Traversing interface

+ Children func() []Traversing

+ Parent func() Traversing

+ Traverse func(axis TraversingAxis, visitor TraversalVisitor) error

+ type TraversingAxis uint

+ const TraverseAncestor

+ const TraverseChild

+ const TraverseDescendant

+ const TraverseDescendantReverse

+ const TraverseRoot

+ const TraverseSelf

+ const TraverseSelfOrAncestor

+ const TraverseSelfOrChild

+ const TraverseSelfOrDescendant

+ const TraverseSelfOrDescendantReverse

+ const TraverseSelfOrSibling

+ const TraverseSelfSiblingOrAncestor

+ const TraverseSibling

+ type ValidateProvider struct

+ func NewValidateProvider(withResult bool) *ValidateProvider

+ func (v *ValidateProvider) Filters(binding Binding, callback any, composer Handler) ([]Filter, error)

+ func (v *ValidateProvider) InitWithTag(tag reflect.StructTag) error

+ func (v *ValidateProvider) Required() bool

+ type Validates struct

+ func (v *Validates) Dispatch(handler any, greedy bool, composer Handler) HandleResult

+ func (v *Validates) Groups() []any

+ func (v *Validates) InGroup(group any) bool

+ func (v *Validates) Key() any

+ func (v *Validates) Metadata() *BindingMetadata

+ func (v *Validates) Outcome() *ValidationOutcome

+ func (v *Validates) Policy() Policy

+ func (v *Validates) Target() any

+ type ValidatesBuilder struct

+ func (b *ValidatesBuilder) NewValidates() *Validates

+ func (b *ValidatesBuilder) Target(target any) *ValidatesBuilder

+ func (b *ValidatesBuilder) WithGroups(groups ...any) *ValidatesBuilder

+ type ValidationInstaller struct

+ func (v *ValidationInstaller) Install(registration *Registration)

+ func (v *ValidationInstaller) ValidateResults()

+ type ValidationOutcome struct

+ func Validate(handler Handler, target any, groups ...any) (*ValidationOutcome, error)

+ func (v *ValidationOutcome) AddError(path string, err error)

+ func (v *ValidationOutcome) Error() string

+ func (v *ValidationOutcome) FieldErrors(path string) []error

+ func (v *ValidationOutcome) Fields() []string

+ func (v *ValidationOutcome) Path(path string) *ValidationOutcome

+ func (v *ValidationOutcome) RequirePath(path string) *ValidationOutcome

+ func (v *ValidationOutcome) Valid() bool