dry-rb/dry-types
Dry Types
This library provides a type system for Ruby applications, offering a framework for defining, validating, and coercing data structures. It serves as a foundation for maintaining data integrity by ensuring that input values conform to established schemas and constraints before they are processed by application logic.
The system distinguishes itself through a functional approach to data transformation and validation. It utilizes an immutable registry for type definitions and employs algebraic operators to compose complex, nested schemas from smaller, reusable components. By wrapping validation outcomes in monadic containers, the library enables predictable error handling and flow control without relying on exceptions.
Beyond basic validation, the toolkit supports recursive structure traversal and lazy coercion, allowing for the transformation of raw inputs from external sources into structured objects. These capabilities facilitate consistent domain modeling, enabling the enforcement of business rules across different layers of a codebase through custom type definitions and flexible schema composition.
Features
- Data Validation Libraries - Provides a comprehensive framework for validating data structures and enforcing constraints within Ruby applications.
- Type System Libraries - Provides a toolkit for defining, validating, and coercing data types to ensure consistent structures.
- Data Validation Schemas - Provides schema-based validation to ensure input data conforms to expected structures and constraints.
- Data Type Coercion - Transforms raw input values into structured objects using built-in or custom conversion rules.
- Coercion Pipelines - Implements pipelines that chain transformation functions to convert raw input data into expected types.
- Custom Type Definitions - Allows the construction of reusable custom type definitions to enforce consistency across application logic.
- Recursive Type Definitions - Supports recursive type definitions that allow for the validation of nested, tree-like data structures.
- Functional Transformations - Provides functional transformation tools to convert raw inputs into structured objects using composable rules.
- Immutable Registries - Maintains an immutable registry of type definitions to ensure consistent and predictable data modeling across application layers.
- Nested Object Validation - Supports recursive validation of nested properties to handle deep objects and complex configuration files.
- Domain Model Implementations - Uses type-safe data structures to model business entities and enforce domain rules.
- Monadic Error Handling - Uses monadic containers to handle validation errors and control flow in a functional manner.
- Success and Failure Wrapping - Encapsulates validation outcomes in functional containers to manage success and failure states without relying on exceptions.
- Function Composition - Enables the composition of small, reusable functions into complex operations for data validation and transformation.
- Predicate-Based Validations - Provides predicate-based validation utilities that check values against defined rules and return explicit success or failure types.
- Schema Composition Libraries - Provides utilities for building complex, nested validation structures by composing reusable schema primitives.
- Error Handling - Integrates validation results into monadic flows to manage application state and handle errors predictably.
