Improve naming of internal types.

aggregate.go

@@ -32,9 +32,9 @@ func FromAggregate(h dogma.AggregateMessageHandler) RichAggregate {
 	return cfg
 }
 
-func fromAggregate(h dogma.AggregateMessageHandler) (*aggregate, *aggregateConfigurer) {
-	cfg := &aggregate{
-		handler: handler{
+func fromAggregate(h dogma.AggregateMessageHandler) (*richAggregate, *aggregateConfigurer) {
+	cfg := &richAggregate{
+		handlerEntity: handlerEntity{
 			entity: entity{
 				rt: reflect.TypeOf(h),
 			},
@@ -47,7 +47,7 @@ func fromAggregate(h dogma.AggregateMessageHandler) (*aggregate, *aggregateConfi
 			entityConfigurer: entityConfigurer{
 				entity: &cfg.entity,
 			},
-			handler: &cfg.handler,
+			handler: &cfg.handlerEntity,
 		},
 	}
 
@@ -56,25 +56,25 @@ func fromAggregate(h dogma.AggregateMessageHandler) (*aggregate, *aggregateConfi
 	return cfg, c
 }
 
-// aggregate is an implementation of RichAggregate.
-type aggregate struct {
-	handler
+// richAggregate the default implementation of [RichAggregate].
+type richAggregate struct {
+	handlerEntity
 
 	impl dogma.AggregateMessageHandler
 }
 
-func (h *aggregate) AcceptVisitor(ctx context.Context, v Visitor) error {
+func (h *richAggregate) AcceptVisitor(ctx context.Context, v Visitor) error {
 	return v.VisitAggregate(ctx, h)
 }
 
-func (h *aggregate) AcceptRichVisitor(ctx context.Context, v RichVisitor) error {
+func (h *richAggregate) AcceptRichVisitor(ctx context.Context, v RichVisitor) error {
 	return v.VisitRichAggregate(ctx, h)
 }
 
-func (h *aggregate) HandlerType() HandlerType {
+func (h *richAggregate) HandlerType() HandlerType {
 	return AggregateHandlerType
 }
 
-func (h *aggregate) Handler() dogma.AggregateMessageHandler {
+func (h *richAggregate) Handler() dogma.AggregateMessageHandler {
 	return h.impl
 }

application.go

@@ -41,8 +41,8 @@ func FromApplication(a dogma.Application) RichApplication {
 	return cfg
 }
 
-func fromApplication(a dogma.Application) (*application, *applicationConfigurer) {
-	cfg := &application{
+func fromApplication(a dogma.Application) (*richApplication, *applicationConfigurer) {
+	cfg := &richApplication{
 		entity: entity{
 			rt: reflect.TypeOf(a),
 		},
@@ -79,31 +79,31 @@ func IsApplicationEqual(a, b Application) bool {
 		a.Handlers().IsEqual(b.Handlers())
 }
 
-// application is an implementation of RichApplication.
-type application struct {
+// richApplication is the default implementation of [RichApplication].
+type richApplication struct {
 	entity
 
 	handlers     HandlerSet
 	richHandlers RichHandlerSet
 	impl         dogma.Application
 }
 
-func (a *application) AcceptVisitor(ctx context.Context, v Visitor) error {
+func (a *richApplication) AcceptVisitor(ctx context.Context, v Visitor) error {
 	return v.VisitApplication(ctx, a)
 }
 
-func (a *application) AcceptRichVisitor(ctx context.Context, v RichVisitor) error {
+func (a *richApplication) AcceptRichVisitor(ctx context.Context, v RichVisitor) error {
 	return v.VisitRichApplication(ctx, a)
 }
 
-func (a *application) Handlers() HandlerSet {
+func (a *richApplication) Handlers() HandlerSet {
 	return a.handlers
 }
 
-func (a *application) RichHandlers() RichHandlerSet {
+func (a *richApplication) RichHandlers() RichHandlerSet {
 	return a.richHandlers
 }
 
-func (a *application) Application() dogma.Application {
+func (a *richApplication) Application() dogma.Application {
 	return a.impl
 }

applicationconfigurer.go

@@ -10,7 +10,7 @@ import (
 type applicationConfigurer struct {
 	entityConfigurer
 
-	app *application
+	app *richApplication
 }
 
 func (c *applicationConfigurer) Identity(name, key string) {

entity.go

@@ -191,7 +191,7 @@ func (m EntityMessageTypes) Foreign() EntityMessageTypes {
 	return f
 }
 
-// entity is a partial implementation of RichEntity.
+// entity is a partial implementation of [RichEntity].
 type entity struct {
 	rt reflect.Type
 

handler.go

@@ -46,6 +46,7 @@ func IsHandlerEqual(a, b Handler) bool {
 		a.MessageNames().IsEqual(b.MessageNames())
 }
 
+// handler is a partial implementation of [RichHandler].
 type handler struct {
 	entity
 	isDisabled bool

handlerconfigurer.go

@@ -19,7 +19,7 @@ import (
 //   - [dogma.ProjectionConfigurer]
 type handlerConfigurer struct {
 	entityConfigurer
-	handler *handler
+	handler *handlerEntity
 }
 
 func (c *handlerConfigurer) Disable(...dogma.DisableOption) {

integration.go

@@ -32,9 +32,9 @@ func FromIntegration(h dogma.IntegrationMessageHandler) RichIntegration {
 	return cfg
 }
 
-func fromIntegration(h dogma.IntegrationMessageHandler) (*integration, *integrationConfigurer) {
-	cfg := &integration{
-		handler: handler{
+func fromIntegration(h dogma.IntegrationMessageHandler) (*richIntegration, *integrationConfigurer) {
+	cfg := &richIntegration{
+		handlerEntity: handlerEntity{
 			entity: entity{
 				rt: reflect.TypeOf(h),
 			},
@@ -47,7 +47,7 @@ func fromIntegration(h dogma.IntegrationMessageHandler) (*integration, *integrat
 			entityConfigurer: entityConfigurer{
 				entity: &cfg.entity,
 			},
-			handler: &cfg.handler,
+			handler: &cfg.handlerEntity,
 		},
 	}
 
@@ -56,25 +56,25 @@ func fromIntegration(h dogma.IntegrationMessageHandler) (*integration, *integrat
 	return cfg, c
 }
 
-// integration is an implementation of RichIntegration.
-type integration struct {
-	handler
+// richIntegration is the default implementation of [RichIntegration].
+type richIntegration struct {
+	handlerEntity
 
 	impl dogma.IntegrationMessageHandler
 }
 
-func (h *integration) AcceptVisitor(ctx context.Context, v Visitor) error {
+func (h *richIntegration) AcceptVisitor(ctx context.Context, v Visitor) error {
 	return v.VisitIntegration(ctx, h)
 }
 
-func (h *integration) AcceptRichVisitor(ctx context.Context, v RichVisitor) error {
+func (h *richIntegration) AcceptRichVisitor(ctx context.Context, v RichVisitor) error {
 	return v.VisitRichIntegration(ctx, h)
 }
 
-func (h *integration) HandlerType() HandlerType {
+func (h *richIntegration) HandlerType() HandlerType {
 	return IntegrationHandlerType
 }
 
-func (h *integration) Handler() dogma.IntegrationMessageHandler {
+func (h *richIntegration) Handler() dogma.IntegrationMessageHandler {
 	return h.impl
 }

process.go

@@ -32,9 +32,9 @@ func FromProcess(h dogma.ProcessMessageHandler) RichProcess {
 	return cfg
 }
 
-func fromProcess(h dogma.ProcessMessageHandler) (*process, *processConfigurer) {
-	cfg := &process{
-		handler: handler{
+func fromProcess(h dogma.ProcessMessageHandler) (*richProcess, *processConfigurer) {
+	cfg := &richProcess{
+		handlerEntity: handlerEntity{
 			entity: entity{
 				rt: reflect.TypeOf(h),
 			},
@@ -47,7 +47,7 @@ func fromProcess(h dogma.ProcessMessageHandler) (*process, *processConfigurer) {
 			entityConfigurer: entityConfigurer{
 				entity: &cfg.entity,
 			},
-			handler: &cfg.handler,
+			handler: &cfg.handlerEntity,
 		},
 	}
 
@@ -56,25 +56,25 @@ func fromProcess(h dogma.ProcessMessageHandler) (*process, *processConfigurer) {
 	return cfg, c
 }
 
-// process is an implementation of RichProcess.
-type process struct {
-	handler
+// richProcess is the default implementation of [RichProcess].
+type richProcess struct {
+	handlerEntity
 
 	impl dogma.ProcessMessageHandler
 }
 
-func (h *process) AcceptVisitor(ctx context.Context, v Visitor) error {
+func (h *richProcess) AcceptVisitor(ctx context.Context, v Visitor) error {
 	return v.VisitProcess(ctx, h)
 }
 
-func (h *process) AcceptRichVisitor(ctx context.Context, v RichVisitor) error {
+func (h *richProcess) AcceptRichVisitor(ctx context.Context, v RichVisitor) error {
 	return v.VisitRichProcess(ctx, h)
 }
 
-func (h *process) HandlerType() HandlerType {
+func (h *richProcess) HandlerType() HandlerType {
 	return ProcessHandlerType
 }
 
-func (h *process) Handler() dogma.ProcessMessageHandler {
+func (h *richProcess) Handler() dogma.ProcessMessageHandler {
 	return h.impl
 }

projection.go

@@ -35,9 +35,9 @@ func FromProjection(h dogma.ProjectionMessageHandler) RichProjection {
 	return cfg
 }
 
-func fromProjection(h dogma.ProjectionMessageHandler) (*projection, *projectionConfigurer) {
-	cfg := &projection{
-		handler: handler{
+func fromProjection(h dogma.ProjectionMessageHandler) (*richProjection, *projectionConfigurer) {
+	cfg := &richProjection{
+		handlerEntity: handlerEntity{
 			entity: entity{
 				rt: reflect.TypeOf(h),
 			},
@@ -51,7 +51,7 @@ func fromProjection(h dogma.ProjectionMessageHandler) (*projection, *projectionC
 			entityConfigurer: entityConfigurer{
 				entity: &cfg.entity,
 			},
-			handler: &cfg.handler,
+			handler: &cfg.handlerEntity,
 		},
 		projection: cfg,
 	}
@@ -61,30 +61,30 @@ func fromProjection(h dogma.ProjectionMessageHandler) (*projection, *projectionC
 	return cfg, c
 }
 
-// projection is an implementation of RichProjection.
-type projection struct {
-	handler
+// richProjection is the default implementation of [RichProjection].
+type richProjection struct {
+	handlerEntity
 
 	impl           dogma.ProjectionMessageHandler
 	deliveryPolicy dogma.ProjectionDeliveryPolicy
 }
 
-func (h *projection) AcceptVisitor(ctx context.Context, v Visitor) error {
+func (h *richProjection) AcceptVisitor(ctx context.Context, v Visitor) error {
 	return v.VisitProjection(ctx, h)
 }
 
-func (h *projection) AcceptRichVisitor(ctx context.Context, v RichVisitor) error {
+func (h *richProjection) AcceptRichVisitor(ctx context.Context, v RichVisitor) error {
 	return v.VisitRichProjection(ctx, h)
 }
 
-func (h *projection) HandlerType() HandlerType {
+func (h *richProjection) HandlerType() HandlerType {
 	return ProjectionHandlerType
 }
 
-func (h *projection) Handler() dogma.ProjectionMessageHandler {
+func (h *richProjection) Handler() dogma.ProjectionMessageHandler {
 	return h.impl
 }
 
-func (h *projection) DeliveryPolicy() dogma.ProjectionDeliveryPolicy {
+func (h *richProjection) DeliveryPolicy() dogma.ProjectionDeliveryPolicy {
 	return h.deliveryPolicy
 }

projectionconfigurer.go

@@ -8,7 +8,7 @@ import (
 
 type projectionConfigurer struct {
 	handlerConfigurer
-	projection *projection
+	projection *richProjection
 }
 
 func (c *projectionConfigurer) Routes(routes ...dogma.ProjectionRoute) {