conformare

Audit Rust error enums for span fields and constructor guarantees.

Updated May 20, 2026
One-click install
npx skills add https://github.com/watmin/datamancy.dev --skill conformare
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: conformare
Source: https://github.com/watmin/datamancy.dev/tree/main/conformare
Command: npx skills add https://github.com/watmin/datamancy.dev --skill conformare

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Conformare audits error-type definitions to ensure diagnostic completeness and enforce structural discipline so that variants cannot omit essential data (e.g., spans) and constructors require necessary fields.

Core Features & Use Cases

  • Audits all error-type enums (and related Result/Step wrappers) for span field presence and documented absence.
  • Evaluates constructor surfaces and From<...> conversions for span preservation.
  • Provides pattern recommendations (Pattern A/B/C) and guidance for retrofitting to achieve structural conformance.
  • Useful for Rust codebases that rely on precise error reporting and want to guarantee runtime diagnostics via the type system.

Quick Start

Audit a Rust project's error types to ensure every variant carries a span and that constructors require it.

Frequently Asked Questions about conformare

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I enforce span fields in Rust error enums to guarantee diagnostic completeness?

You can enforce span fields in Rust error enums by auditing error-type definitions for structural conformance, ensuring all variants carry essential diagnostic data and constructors require necessary fields.

What is the best way to audit Rust error types for missing diagnostic spans?

Auditing Rust error types for missing diagnostic spans involves evaluating all enum variants, related Result wrappers, and From conversions to verify span field presence and preservation.

How do I retrofit existing Rust error variants to require span data in their constructors?

Retrofitting existing Rust error variants to require span data is guided by applying structured pattern recommendations, such as Pattern A, B, or C, to achieve structural type-safety conformance.

Can I use static analysis to check if my Rust From conversions preserve error spans?

Yes, static analysis can check if your Rust From conversions preserve error spans by evaluating constructor surfaces and conversions to ensure span preservation across the entire codebase.

Does this type-safety audit work with Rust codebases using enum-based errors and Step wrappers?

This type-safety audit works directly with Rust codebases using enum-based errors by evaluating all related Result and Step wrappers for documented span absence and structural discipline.

When should I not use structural conformance audits for Rust error handling?

You should avoid structural conformance audits for Rust error handling when your codebase does not rely on precise error reporting or lacks enum-based error types requiring runtime diagnostic spans.