typescript-effect

Enforce functional TypeScript patterns using the Effect ecosystem.

2|Updated Aug 25, 2025
One-click install
npx skills add https://github.com/bsamiee/Parametric_Forge --skill typescript-effect
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: typescript-effect
Source: https://github.com/bsamiee/Parametric_Forge/tree/main/.claude/skills/typescript-effect
Command: npx skills add https://github.com/bsamiee/Parametric_Forge --skill typescript-effect

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

Enforces functional TypeScript patterns with the Effect ecosystem. Use for TS functions, types, error handling, and modular pipelines.

Core Features & Use Cases

  • Six pillars: algorithmic, parametric, polymorphic, functional, expression-centric, strong-typed.
  • Code structure with clear dispatch tables and branded types.
  • Encourages explicit, typed pipelines over imperative blocks.

Quick Start

Generate a small function using branded types and a simple dispatch table.

Frequently Asked Questions about typescript-effect

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

FAQPage Schema
How do I enforce functional TypeScript patterns across my codebase?

Enforce functional TypeScript patterns using the Effect ecosystem to structure pipelines, define branded types, and use dispatch tables instead of conditionals. This approach ensures typed, expressive code that avoids imperative blocks and maintains strong type safety throughout your functions and modules.

What's the best way to handle errors in TypeScript without try/catch blocks?

Model errors with Effect channels instead of try/catch to create explicit, typed error handling. This replaces imperative exception handling with functional error propagation, integrating seamlessly into Effect pipelines and maintaining type-driven error workflows.

How do I structure TypeScript code with dispatch tables and branded types?

Structure code by defining branded types for domain concepts and creating dispatch tables to route operations functionally. This eliminates conditional branching, centralizes logic, and produces strongly typed, expression-centric implementations aligned with functional programming principles.

Can I use Effect patterns to avoid mutable state in TypeScript?

Yes. Use const-only variables and Effect pipelines to eliminate mutable state. The Effect ecosystem enforces immutability and functional composition, ensuring your TypeScript codebase remains declarative and side-effect-free by design.

What are the six pillars of this functional TypeScript approach?

The six pillars are algorithmic, parametric, polymorphic, functional, expression-centric, and strong-typed. Together they guide code structure, type definitions, and pipeline design to produce explicit, reusable, and type-safe TypeScript modules.

Do I need to avoid the 'any' type when using Effect patterns?

Yes. Avoiding 'any' is a core requirement. The Effect ecosystem enforces explicit typing throughout, ensuring compile-time safety and eliminating type escape hatches that undermine functional correctness and type-driven error handling.