golang-samber-ro

Design reactive asynchronous pipelines in Go with samber/ro typed operators.

2|Updated Feb 12, 2024
One-click install
npx skills add https://github.com/adibfirman/dotfiles --skill golang-samber-ro-adibfirman
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: golang-samber-ro
Source: https://github.com/adibfirman/dotfiles/tree/main/claude/.claude/skills/technical/golang/golang-samber-ro
Command: npx skills add https://github.com/adibfirman/dotfiles --skill golang-samber-ro-adibfirman

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill helps you design and implement asynchronous, potentially infinite, reactive dataflows in Go without tangled goroutines and fragile channel/error handling.

Core Features & Use Cases

  • Reactive streams with type-safe operators: Compose end-to-end pipelines using ro.Pipe2 through ro.Pipe25 to keep transformations correct at compile time.
  • Cold vs hot execution and subject-based event buses: Use Share, ShareReplay, and the five subject types (Publish/Behavior/Replay/Async/Unicast) to match your event lifecycle.
  • Production-grade controls: Apply backpressure-oriented stream design patterns, retries with exponential backoff, timeouts, batching, and robust error propagation through the pipeline error channel.
  • Go context integration for cancellation: Respect request timeouts and shutdown signals using context operators and context-cancel-to-error conversion.

Quick Start

Ask for a Go example that builds a samber/ro pipeline using typed Pipe operators, retries with backoff, and context cancellation for graceful shutdown.

Frequently Asked Questions about golang-samber-ro

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

FAQPage Schema
How do I build type-safe reactive pipelines in Go without manually managing goroutines and channels?

Type-safe reactive pipelines in Go can be built using samber/ro's typed Pipe2 through Pipe25 operators to chain asynchronous transformations, replacing fragile manual goroutine and channel handling with compile-time verified stream processing.

What's the best way to handle cold vs hot execution semantics for event buses in Go reactive streams?

Cold vs hot execution semantics in Go reactive streams are managed using Share and ShareReplay alongside five subject types (Publish, Behavior, Replay, Async, Unicast) to accurately match event bus lifecycle and multicast distribution requirements.

How do I implement backpressure and retry logic in an asynchronous Go dataflow?

Backpressure and retry logic in asynchronous Go dataflows are implemented via backpressure-oriented stream design patterns and configurable retries with exponential backoff, providing production-grade control over high-throughput event processing.

Does Go context integration support cancellation and graceful shutdown in reactive pipelines?

Go context integration supports cancellation and graceful shutdown in reactive pipelines through dedicated context operators that convert context cancellation signals into pipeline errors, enforcing request timeouts and robust stream termination.

How does error propagation work across typed operators in Go event-processing pipelines?

Error propagation across typed operators in Go event-processing pipelines works by routing failures through a dedicated pipeline error channel, ensuring robust asynchronous error handling without interrupting the primary data stream.

When do I need reactive streams for infinite interval processing in Go?

Reactive streams for infinite interval processing in Go are needed when handling continuous sources like WebSocket or file-watcher events, enabling real-time data enrichment and batching without blocking application execution.