Skip to content

Releases: obinexus/functor-frameworks

Functor Framework v0.1.0 - Initial Release

18 Jan 21:56
@obinexus obinexus
functor-frameworks
ac8cd51

Choose a tag to compare

View all tags
Functor Framework v0.1.0 - Initial Release Latest
Latest

Functor Framework v0.1.0 - Initial Release

🎯 Core Innovation

A Phenomenological Type System for Lossless DAG-Based Isomorphic Modeling with 95.4% Coherence and Neurodivergent-First Design.

✨ Key Features

Type System Foundation

  • Heterogeneous Functors (He): Works on mixed data types (A, B, C)
  • Homogeneous Functors (Ho): Works on uniform data types T
  • Set-Theoretic Relations: ∀ He ⊃ Ho and ∃ Ho ⊄ He

DAG Architecture

  • Lossless DAG: Union-based (Time ⊗ Union Set) - temporal modeling
  • Isomorphic DAG: Disjoint-based (Division ⊘ Disjoint Set) - spatial modeling
  • O(log n) Complexity Enforcement: Compile-time auxiliary space validation

Phenomenological Pipeline

Phenotype (Observable)
    ↓ observe()
Phenomemory (Captured)
    ↓ consume()
Phenovalue (Derived)

UML Cardinality Extensions

  • Union (∪): Lossless expansion (1..*)
  • Disjoint (⊔): Isomorphic separation (0..*)
  • Pairing (⊗): Temporal linking (0..1)
  • Division (⊘): Context separation (*..*​)

📦 What's Included

Core Modules

  • functor-base/ - He/Ho functor abstractions
  • dag-engine/ - Lossless/Isomorphic DAG implementation
  • complexity-validator/ - O(log n) compile-time checks

Architecture Patterns

  • observer-consumer/ - Phenotype → Phenomemory → Phenovalue
  • actor-watcher/ - Verb-Action-Actor model
  • dag-optimizer/ - Performance optimization

Separation of Concerns (5W1H)

  • HOW: Design solution patterns
  • WHAT: Problem domain (He vs Ho)
  • WHY: Prevent degradation
  • WHO: Actor-Observer-Consumer
  • WHEN: Temporal boundaries
  • WHERE: Deployment topology

🚀 Quick Start

1. Define Heterogeneous Functor

use functor_framework::prelude::*;

struct HeterogeneousFunctor<A, B> {
    phenotype_a: PhantomData<A>,
    phenotype_b: PhantomData<B>,
}

impl<A, B> Functor for HeterogeneousFunctor<A, B> {
    type Input = (A, B);
    type Output = PhantomData<(A, B)>;
    
    fn map(&self, input: Self::Input) -> Self::Output {
        PhantomData
    }
}

2. Define Homogeneous Functor

struct HomogeneousFunctor<T> {
    phenotype: PhantomData<T>,
}

impl<T> Functor for HomogeneousFunctor<T> {
    type Input = T;
    type Output = T;
    
    fn map(&self, input: Self::Input) -> Self::Output {
        input
    }
}

3. Verify Containment Relation

fn verify_containment<He, Ho>()
where
    He: HeterogeneousFunctor,
    Ho: HomogeneousFunctor,
{
    let _proof: ContainmentProof<He, Ho> = ContainmentProof::new();
}

🎓 Real-World Example: Car Driving System

// Phenotype: What we observe
struct Car {
    color: Color,
    speed: f64,
}

// Phenomemory: What we capture
struct DrivingSession {
    start_time: Time,
    end_time: Time,
    actor: Driver,
}

// Phenovalue: What we derive
struct TripSummary {
    distance: f64,
    fuel_used: f64,
}

// Functor: He (works on Car, DrivingSession, Driver)
struct DrivingFunctor;

impl Functor for DrivingFunctor {
    type Input = (Car, DrivingSession);
    type Output = TripSummary;
    
    fn map(&self, input: Self::Input) -> Self::Output {
        let (car, session) = input;
        TripSummary {
            distance: calculate_distance(&session),
            fuel_used: calculate_fuel(&car, &session),
        }
    }
}

🔗 Integration with HDIS

The Functor Framework serves as the type-level foundation for the Hybrid Directed Instruction System (HDIS):

HDIS (Runtime Layer)
    ↓
Functor Framework (Type Layer)
    ↓
DAG Engine (Execution Layer)
    ↓
O(log n) Validator (Safety Layer)

🧠 Design Principles

Verb-Action-Actor Model

  • Noun: Car (the thing) - Phenotype
  • Verb: Drive (the action/memory) - Phenomemory
  • Actor: Driver (who observes/consumes) - Phenovalue
  • Adjective: blue/red (instantiation variation)

Set-Theoretic Guarantees

  • All binders are drivers (He ⊃ Ho)
  • All squares are rectangles (He ⊃ Ho)
  • NOT all drivers are binders (Ho ⊄ He)
  • NOT all rectangles are squares (Ho ⊄ He)

📊 Performance Characteristics

  • Auxiliary Space Complexity: O(log n) enforced at compile-time
  • Coherence Rating: 95.4% (PLP - Phenomenological Lensing Protocol)
  • Type Safety: Compile-time verification of He ⊃ Ho relations
  • Memory Efficiency: Lossless transformations with minimal overhead

🌍 OBINexus Ecosystem

Part of the OBINexus Computing suite:

  • Functor Framework (this repository) - Type system foundation
  • HDIS - Hybrid Directed Instruction System
  • LibPolyCall - Polymorphic call routing
  • Constitutional Housing Framework - Legal/rights layer

📝 License

OBINexus License - Neurodivergent-First, MIT-compatible

See [LICENSE](LICENSE) for details.

🤝 Contributing

We welcome contributions that maintain:

  1. O(log n) auxiliary space for all implementations
  2. He ⊃ Ho containment relation preservation
  3. Lossless DAG transformations for temporal models
  4. Isomorphic DAG transformations for spatial models
  5. Phenotype-Phenomemory-Phenovalue pipeline integrity

See [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines.

📚 Documentation

🔮 Roadmap

v0.2.0 (Planned)

  • Extended phenotype clustering
  • Advanced DAG optimization strategies
  • Additional UML cardinality operators
  • Performance benchmarks

v0.3.0 (Future)

  • Full HDIS integration
  • GraphQL schema generation
  • Visual DAG editor
  • Real-time phenomemory capture

📞 Contact

OBINexus Computing

🙏 Acknowledgments

Built with:

  • Set Theory foundations from mathematical computing
  • UML cardinality extensions for real-world modeling
  • Phenomenological philosophy for neurodivergent-first design
  • DAG optimization from graph theory research

📌 Tags

functor-framework heterogeneous-functors homogeneous-functors dag-optimization phenotype-model phenomemory phenovalue set-theory uml-cardinality lossless-dag isomorphic-mapping obinexus hdis-integration o-log-n-complexity type-system rust-framework actor-observer-consumer verb-action-actor directed-acyclic-graph compile-time-verification

"Architecture is the seed. The Functor Framework is how it grows."

— OBINexus Computing, 2026

Installation

# Clone the repository
git clone https://github.com/obinexus/functor-framework.git

# Navigate to directory
cd functor-framework

# Build the project
cargo build --release

# Run tests
cargo test

# Generate documentation
cargo doc --open

Release Date: January 18, 2026
Version: 0.1.0
Codename: "Phenomenological Seed"

Assets 2
Loading