functional_skill

Overview

This skill codifies pragmatic functional programming patterns focused on immutable data and pure functions. It offers guidance for writing predictable, testable, and composable logic without heavy FP abstractions. Use it to shape transformation logic, APIs, and domain code toward clarity and safety.

How this skill works

The skill inspects code and design choices to enforce immutable updates, prefer pure functions, and favor composition and array methods over imperative loops. It recommends using options objects for multi-parameter functions, readonly types where available, and isolating impurity at system boundaries. It also suggests concrete refactors: small named functions, early returns, and limited nesting depth.

When to use it

• Writing data transformations or business logic
• Refactoring mutable code to predictable, testable functions
• Designing public APIs and library primitives
• Preparing code for concurrent or React-based environments
• Teaching or documenting team-level coding standards

Best practices

• Prefer pure functions; isolate I/O and side effects at the edges
• Never mutate inputs—return new objects/arrays instead of modifying existing ones
• Use array methods (map, filter, reduce) for declarative transformations
• Favor options objects for functions with many or optional parameters
• Limit nesting to two levels; extract descriptive helper functions
• Annotate intent with readonly (or equivalent) to communicate immutability

Example use cases

• Convert imperative loops that mutate state into chained array transforms (map → filter → reduce)
• Refactor a function that mutates objects into one that returns a new object using spread or structural updates
• Design a public API that accepts a single options object for clarity and future extension
• Isolate side effects: keep calculation functions pure and put persistence in small adapter functions
• Simplify complex validation by composing small validators and a final registration step