Module modular_framework 

Modular Framework for Component Composition

This module provides a comprehensive framework for building modular, composable systems with support for component lifecycle management, dependency resolution, event-driven communication, pipeline execution, and advanced composition patterns.

The framework is organized into several key modules:

Core Components

Component Framework

• component_framework - Core component abstractions, factory patterns, and registry
• registry_system - Component registration, discovery, and lifecycle management
• lifecycle_management - Component lifecycle states and dependency-aware initialization

Communication and Events

• event_system - Event-driven communication with publish-subscribe patterns
• dependency_management - Dependency resolution, compatibility checking, and injection

Execution and Orchestration

• pipeline_system - Modular pipeline configuration and execution strategies
• execution_engine - Composition execution engine with resource management

Advanced Composition

• advanced_composition - Type-safe, functional, and algebraic composition patterns

Quick Start

use sklears_compose::modular_framework::{ComponentConfig, ComponentFramework, PipelineBuilder};

let _framework = ComponentFramework::new();
let pipeline = PipelineBuilder::new()
    .add_stage("preprocessor", ComponentConfig::new("pre", "standard_scaler"))
    .add_stage("trainer", ComponentConfig::new("train", "random_forest"))
    .build()
    .unwrap();
assert_eq!(pipeline.stages.len(), 2);

Architecture Overview

The modular framework follows a layered architecture:

┌─────────────────────────────────────────────────────────────┐
│                Advanced Composition                         │
│  Type-Safe • Functional • Algebraic • Higher-Order         │
├─────────────────────────────────────────────────────────────┤
│                  Execution Engine                          │
│   Resource Management • Scheduling • Orchestration         │
├─────────────────────────────────────────────────────────────┤
│                  Pipeline System                           │
│   Sequential • Parallel • Conditional • Error Handling     │
├─────────────────────────────────────────────────────────────┤
│              Communication Layer                           │
│   Event System • Dependency Management • Injection         │
├─────────────────────────────────────────────────────────────┤
│                Component Framework                         │
│   Registry • Lifecycle • Factory • Configuration           │
└─────────────────────────────────────────────────────────────┘

Key Features

• Type Safety: Compile-time guarantees for component composition
• Lifecycle Management: Dependency-aware component initialization and shutdown
• Event-Driven: Decoupled communication through publish-subscribe patterns
• Pipeline Execution: Flexible execution strategies with error handling
• Resource Management: Intelligent allocation and monitoring of system resources
• Dependency Resolution: Automatic dependency resolution with circular detection
• Functional Composition: Higher-order abstractions and category theory patterns
• Performance Monitoring: Comprehensive metrics and execution statistics

Re-exports

pub use component_framework::CapabilityMismatch;

pub use component_framework::CapabilityMismatchSeverity;

pub use component_framework::CompatibilityReport;

pub use component_framework::ComponentCapability;

pub use component_framework::ComponentConfig;

pub use component_framework::ComponentDependency;

pub use component_framework::ComponentEvent as FrameworkComponentEvent;

pub use component_framework::ComponentFactory;

pub use component_framework::ComponentInfo;

pub use component_framework::ComponentMetadata;

pub use component_framework::ComponentMetrics;

pub use component_framework::ComponentNode;

pub use component_framework::ComponentRegistry;

pub use component_framework::ComponentState;

pub use component_framework::ComponentStatus;

pub use component_framework::ConfigValue;

pub use component_framework::EnvironmentSettings;

pub use component_framework::ExecutionCondition;

pub use component_framework::ExecutionConditionType;

pub use component_framework::ExecutionMetadata;

pub use component_framework::ExecutionStatus;

pub use component_framework::HealthStatus;

pub use component_framework::LogLevel;

pub use component_framework::MetricValue;

pub use component_framework::MissingDependency;

pub use component_framework::PluggableComponent;

pub use component_framework::ResourceConstraints;

pub use component_framework::ResourceLimits;

pub use component_framework::ResourceUsage;

pub use component_framework::SecuritySettings;

pub use component_framework::VersionConflict;

pub use registry_system::ComponentQuery;

pub use registry_system::ComponentRegistrationMetadata;

pub use registry_system::ComponentTypeInfo;

pub use registry_system::ComponentVersionInfo;

pub use registry_system::GlobalComponentRegistry;

pub use registry_system::PluginLoadResult;

pub use registry_system::RegistryConfiguration;

pub use registry_system::RegistryError;

pub use registry_system::RegistryHooks;

pub use registry_system::RegistryStatistics;

pub use lifecycle_management::ComponentLifecycleState;

pub use lifecycle_management::InitializationResult;

pub use lifecycle_management::LifecycleConfig;

pub use lifecycle_management::LifecycleEvent;

pub use lifecycle_management::LifecycleManager;

pub use lifecycle_management::LifecycleMetrics;

pub use lifecycle_management::ShutdownResult;

pub use event_system::ComponentEvent;

pub use event_system::EventBus;

pub use event_system::EventCategory;

pub use event_system::EventHandler;

pub use event_system::EventMetadata;

pub use event_system::EventPriority;

pub use event_system::EventProcessingResult;

pub use event_system::EventRoutingConfig;

pub use event_system::EventStatistics;

pub use event_system::RoutingRule;

pub use event_system::RoutingStrategy;

pub use dependency_management::CircularDependency;

pub use dependency_management::CompatibilityIssue;

pub use dependency_management::CompatibilityIssueType;

pub use dependency_management::CompatibilityResult;

pub use dependency_management::ConflictType;

pub use dependency_management::DependencyConflict;

pub use dependency_management::DependencyError;

pub use dependency_management::DependencyGraph;

pub use dependency_management::DependencyInjectionRegistry;

pub use dependency_management::DependencyNode;

pub use dependency_management::DependencyProvider;

pub use dependency_management::DependencyResolutionConfig;

pub use dependency_management::DependencyResolver;

pub use dependency_management::DependencyState;

pub use dependency_management::DependencyStatistics;

pub use dependency_management::ResolutionResult;

pub use dependency_management::VersionConstraint;

pub use dependency_management::VersionConstraintSolver;

pub use pipeline_system::BackoffStrategy;

pub use pipeline_system::ConditionalExecution;

pub use pipeline_system::ErrorHandlingStrategy;

pub use pipeline_system::ExecutionContext;

pub use pipeline_system::ExecutionStrategy;

pub use pipeline_system::ExecutionTrace;

pub use pipeline_system::ModularPipeline;

pub use pipeline_system::ModularPipelineBuilder;

pub use pipeline_system::ParallelBranch;

pub use pipeline_system::Pipeline;

pub use pipeline_system::PipelineBuilder;

pub use pipeline_system::PipelineConfig;

pub use pipeline_system::PipelineConfiguration;

pub use pipeline_system::PipelineData;

pub use pipeline_system::PipelineError;

pub use pipeline_system::PipelineMetadata;

pub use pipeline_system::PipelineMetrics;

pub use pipeline_system::PipelineResult;

pub use pipeline_system::PipelineStage;

pub use pipeline_system::PipelineState;

pub use pipeline_system::PipelineStep;

pub use pipeline_system::RetryConfig;

pub use pipeline_system::RetryConfiguration;

pub use pipeline_system::RetryPolicy;

pub use pipeline_system::StageMetrics;

pub use pipeline_system::StageResult;

pub use pipeline_system::StageType;

pub use pipeline_system::TimeoutAction;

pub use pipeline_system::TimeoutConfig;

pub use execution_engine::ComponentExecutionResult;

pub use execution_engine::CompositionContext;

pub use execution_engine::CompositionExecutionEngine;

pub use execution_engine::CompositionGraph;

pub use execution_engine::CompositionNode;

pub use execution_engine::CompositionResult;

pub use execution_engine::ConcurrentExecution;

pub use execution_engine::ContextState;

pub use execution_engine::ExecutionEngineConfig;

pub use execution_engine::ExecutionEngineError;

pub use execution_engine::ExecutionPlan;

pub use execution_engine::ExecutionPriority;

pub use execution_engine::ExecutionResult;

pub use execution_engine::ExecutionScheduler;

pub use execution_engine::ExecutionStatistics;

pub use execution_engine::ResourceAllocation;

pub use execution_engine::ResourceAllocationStrategy;

pub use execution_engine::ResourceManager;

pub use advanced_composition::AdvancedCompositionError;

pub use advanced_composition::AlgebraicComposer;

pub use advanced_composition::AlgebraicComposition;

pub use advanced_composition::AlgebraicOperation;

pub use advanced_composition::Applicative;

pub use advanced_composition::ApplicativeFunctor;

pub use advanced_composition::CategoryMorphism;

pub use advanced_composition::Composition;

pub use advanced_composition::CompositionCombinator;

pub use advanced_composition::CompositionFunction;

pub use advanced_composition::CompositionMetadata;

pub use advanced_composition::CompositionType;

pub use advanced_composition::ConstraintType;

pub use advanced_composition::FunctionalComposer;

pub use advanced_composition::FunctionalComposition;

pub use advanced_composition::Functor;

pub use advanced_composition::HigherOrderComposer;

pub use advanced_composition::HigherOrderComposition;

pub use advanced_composition::HigherOrderTransform;

pub use advanced_composition::MetaComposition;

pub use advanced_composition::Monad;

pub use advanced_composition::MonadTransformer;

pub use advanced_composition::ParallelBranch as TypedParallelBranch;

pub use advanced_composition::PatternMatcher;

pub use advanced_composition::ProductTypeComposition;

pub use advanced_composition::RecursiveCompositionPattern;

pub use advanced_composition::SumTypeComposition;

pub use advanced_composition::TypeConstraint;

pub use advanced_composition::TypeConstraints;

pub use advanced_composition::TypePredicate;

pub use advanced_composition::TypeSafeComposer;

pub use advanced_composition::TypedComposition;

pub use advanced_composition::TypedTransformer;

Modules

advanced_composition

Advanced Composition Patterns

component_framework

Core Component Framework

dependency_management

Dependency Management System

event_system

Event System for Component Communication

execution_engine

Execution Engine for Modular Composition

lifecycle_management

Component Lifecycle Management System

pipeline_system

Pipeline System for Modular Composition

registry_system

Component Registry System

Structs

ComponentFramework

High-level facade for the modular framework

ComponentFrameworkBuilder

Builder for creating modular frameworks with custom configuration

FrameworkStatistics

Comprehensive framework statistics

Functions

_module_docs

Module-level documentation tests