perspicere

Detect deeply nested generic types and propose typealias names.

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

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Deeply-nested type expressions obscure the noun at the core of a type. Perspicere surfaces that noun and suggests a precise type alias to name it, reducing cognitive load and improving readability.

Core Features & Use Cases

  • Flag deeply nested types (2 or more '<' levels) and identify the noun at the bottom.
  • Propose readable typealias names that reflect the true meaning of complex types.
  • Support conditioning tests and selective exemptions via runes when aliasing is impractical.

Quick Start

Give a deeply nested type like Sender<Vector<Option<HolonAST>>> and request a named typealias that captures the underlying noun.

Frequently Asked Questions about perspicere

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

FAQPage Schema
How do I name deeply nested generic type expressions to improve code readability?

Deeply nested types obscure the core noun they describe, increasing cognitive load. Naming these nested generic expressions with readable typealiases improves code comprehension and maintainability across complex module hierarchies.

How do I extract the underlying noun from a complex generic type signature?

Extract the underlying noun by analyzing the nesting depth of generic type signatures to surface the base type. The analysis proposes a precise typealias name that captures this hidden noun to enhance codebase readability.

Can I check if a matching typealias already exists before creating a new one?

Yes, when proposing a typealias for a nested type, the analysis indicates whether a matching alias already exists elsewhere in the codebase. This prevents duplicate alias definitions and maintains naming consistency across modules.

What is the threshold for a generic type to be considered deeply nested and needing an alias?

A generic type is considered deeply nested when it contains two or more '<' characters. At this nesting depth, the core noun is sufficiently obscured to warrant extracting it and proposing a readable typealias.

How do I apply type aliasing patterns when refactoring complex type hierarchies?

Apply aliasing patterns during refactoring by detecting deeply nested types, surfacing their hidden noun, and proposing a concise typealias name. This allows you to replace complex expressions with readable names across your codebase.

When should I not use a typealias for a deeply nested type?

When aliasing is impractical due to specific codebase constraints, you can apply conditioning tests and selective exemptions via runes. This allows you to bypass aliasing requirements for specific nested types where renaming is not feasible.