dhall-lang/dhall-lang

Features

• Type-Safe Configuration Languages - Provides a programmable language specifically designed for creating validated, type-safe structured configuration files.
• Deterministic Configuration Engines - Provides a deterministic configuration engine that ensures security and consistency through semantic hashing and normalization.
• Non-Turing-Complete Languages - Uses a non-Turing-complete language specification to guarantee that all configuration evaluations terminate.
• Termination Guarantees - Use a strict type system to ensure configuration files are well-formed and guaranteed to terminate.
• Configuration Logic Reusability - Enables the creation of shareable configuration logic using let-bindings, anonymous functions, and explicit polymorphism.
• Typed Configuration Schemas - Enforce a schema on configuration files using type annotations to reject invalid structures.
• Configuration Record Operations - Perform complex record operations including shallow overrides, nested field syntax, and subset projection.
• Record Completion - Fills missing record fields automatically using a schema that defines required types and default values.
• Schema Validators - Enforces strict data structures and types on configuration files to reject invalid inputs.
• Configuration Format Converters - Evaluates programmable configurations into a normal form and converts them into static formats like JSON or YAML.
• Configuration File Generators - Produces formatted configuration files for external tools by converting type-safe definitions into YAML, JSON, or CloudFormation.
• Programmable - Uses functions and variables to reduce redundancy and generate complex JSON or YAML files.
• External File Importers - Resolve local paths or remote URLs to integrate external configuration files and raw text.
• Expression Imports - Resolve local file paths into expressions to share types, functions, or values across files.
• Configuration Imports - Load reusable code and configuration fragments from other files or remote URLs to avoid duplication.
• Configuration Schemas - Check a configuration file against a predefined schema to ensure it meets required types.
• Configuration Merging - Combine multiple records into a single output using a merge operator.
• JSON-to-YAML Converters - Compiles type-safe programmable expressions into static formats such as JSON, YAML, Bash, or Nix.
• Programmatic Configuration Generation - Generate repetitive configuration blocks programmatically using functions and variables to ensure consistency.
• Boolean Logic Evaluation - Evaluate truth values using logical operators and conditional expressions to control configuration flow.
• Configuration Logic Functions - Implements custom functions within the configuration language to generate complex records based on input arguments.
• Configuration Marshalling - Converts interpreted normal forms into standard static data formats like JSON or YAML.
• Data Marshalling - Translate programmable configuration into static formats like JSON or YAML for other applications.
• Expression Evaluators - Evaluates programmable configuration into plain data through resolution, type checking, and normalization.
• Type-Safe Data Structures - Allows the definition of structured data using a strict type system with records, lists, and union types.
• Sum Types - Implements sum types (tagged unions) to ensure a value belongs to a specific set of distinct alternatives.
• List Types - Create ordered sequences of a single type with support for indexing, reversing, and folding.
• Local Bindings - Assigns names to expressions via let-bindings to enable reuse and improve readability within a file.
• Normalization Pipelines - Transforms programmable expressions into a canonical normal form through a multi-phase pipeline of resolution and reduction.
• Parametric Polymorphism - Provides explicit polymorphism allowing the creation of reusable logic that operates on multiple different types.
• Record Types - Manipulate structured data using recursive merging, field projection, and schema-based auto-completion.
• Termination Verifiers - Guarantees that evaluation always terminates by utilizing a non-Turing-complete language specification.
• Type Checking - Uses a strict type system to validate configuration structures and ensure correctness before evaluation.
• Union Types - Use union types to represent multiple possible value types when bridging typed configurations to weakly typed outputs.
• Code Execution Prevention - Prevents the execution of arbitrary scripts by treating configuration as non-Turing-complete data.
• Dependency Integrity Verifiers - Ensures remote imports are untampered using semantic SHA256 hashes of the abstract syntax tree.
• Canonical Normalization - Produces a canonical normal form by eliminating all indirection to verify the behavior of the configuration logic.
• Type-Safe Configurations - Ensures configuration files are valid and predictable using a strict type system and fixed grammar.
• Variable Bindings - Define reusable values using let-expressions to avoid duplicating data across a configuration.
• Schema Default Values - Provides specialized assignment operators to apply fallback values when configuration inputs are missing.
• Remote Expression Imports - Fetch remote expressions via HTTP using custom headers to distribute shared packages.
• Version Pinning - Secures external imports using cryptographic hashes to lock them to a specific version.
• Integer Arithmetic - Calculate sums, differences, and products using natural numbers and integers.
• Programmable Configurations - Provides a system for building reusable configuration logic using functions, polymorphism, and record completion.
• Semantic Hashing - Ensures the integrity of remote imports by calculating cryptographic hashes of the abstract syntax tree.
• Church-Encoded Recursion - Translates recursive data structures into a compatible non-recursive format using Church encoding to guarantee termination.
• Church-Encoded Pattern Matching - Convert Church-encoded values back into union types to enable standard conditional logic.
• Native Data Marshallers - Decodes expressions directly into strongly typed data structures within the host programming language.
• Nested Record Mutations - Modify specific values deep within a record structure without redefining the entire object.
• Cross-Language Marshallers - Converts interpreted expressions into target file formats or language bindings like JSON and YAML.
• Remote Resource Resolution - Provides mechanisms for resolving and fetching configuration expressions from external remote URLs and local files.
• Language Server Protocol Implementations - Implements the Language Server Protocol to provide auto-completion and formatting for configuration files in compatible editors.
• Language Server Protocol Integrations - Implements the Language Server Protocol to provide autocomplete, formatting, and navigation in compatible editors.
• LSP Editor Integrations - Implements the Language Server Protocol to provide auto-completion and formatting in compatible text editors.
• Configuration Distribution and Sharing - Shares reusable configuration logic across teams using hashed remote imports to ensure integrity.
• Configuration File Loading - Reads configuration files directly into programming languages using native bindings to ensure type safety.
• Infrastructure as Code Tools - Provides a type-safe layer for generating cloud templates and system settings for external infrastructure tools.
• Expression Equality Verifiers - Provides a built-in mechanism to assert that two expressions are functionally equivalent.
• External Value Imports - Fetches configuration values from local files, environment variables, or web services to reduce redundancy.
• Immutable Record Updates - Modify specific fields within deeply nested records or optional values without recreating the structure.
• Import Restrictions - Restricts web-imported expressions from accessing local files or environment variables to prevent data exfiltration.
• List Folding - Combine all elements of a list into a single output value using a folding function.
• Normal Form Evaluation - Reduces expressions and functions to their simplest representation by removing all imports and indirection.
• Domain Specific Languages - Allows the creation of serializable, type-safe domain-specific languages using a non-Turing-complete model.
• Import Origin Policies - Enforces a same-origin header policy to prevent credential leaking during remote expression imports.
• Record Completion - Fills missing record fields by merging user input with predefined type schemas and default values.
• Import Fallback Chains - Switch to a secondary import alternative if the primary source fails to resolve.
• Optional Value Types - Represent the presence or absence of a value using a type-safe wrapper.

Star history