golang-samber-ro

Generate Go reactive pipelines with samber/ro operators and subjects.

Updated May 28, 2026
One-click install
npx skills add https://github.com/vanstinator/semantic-search --skill golang-samber-ro-vanstinator
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: golang-samber-ro
Source: https://github.com/vanstinator/semantic-search/tree/main/.agents/skills/golang-samber-ro
Command: npx skills add https://github.com/vanstinator/semantic-search --skill golang-samber-ro-vanstinator

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

It helps you build and maintain asynchronous or infinite data-processing flows in Go without brittle goroutine and channel choreography, while keeping errors, backpressure, and cancellation correct.

Core Features & Use Cases

  • Declarative reactive pipelines: chain 150+ operators with compile-time type safety via typed Pipe functions, including Map/Filter/FlatMap and timed operators.
  • Correct stream lifecycle management: use observers with onNext/onError/onComplete, subscriptions with Wait/Unsubscribe, and context integration for clean shutdown.
  • Hot/cold composition and subjects: model shared event streams with Share/ShareReplay or dedicated subject types (Publish, Behavior, Replay, Async, Unicast).
  • Use cases: infinite event ingestion (WebSockets, file watchers, tickers), real-time enrichment combining multiple sources, and resilient pipelines using retry, timeouts, and fallbacks.

Quick Start

Ask Claude Code to build a debounced file-change reactive pipeline in Go using samber/ro to watch a directory and reload configuration safely with backpressure-aware operators.

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 manual goroutine choreography?

Type-safe reactive pipelines in Go use typed Pipe functions to chain operators like Map, Filter, and FlatMap with compile-time type safety, avoiding brittle goroutine and channel choreography while keeping errors and backpressure correct.

When should I use samber/ro for reactive streaming instead of samber/lo for slice transforms?

Use samber/ro for reactive streaming when handling real-time, infinite, or long-lived observables requiring pub/sub fan-out and graceful cancellation, and use samber/lo for finite slice transforms that do not require stream lifecycle management.

What is the best way to handle graceful shutdown for infinite event streams in Go?

Graceful shutdown for infinite event streams in Go requires using observers with explicit onError and onComplete handlers, subscriptions with Unsubscribe, and context integration to bound the stream lifecycle and ensure clean cancellation.

How do I model shared event streams for pub/sub fan-out in a Go reactive pipeline?

Shared event streams for pub/sub fan-out in a Go reactive pipeline are modeled using Share or ShareReplay operators, or dedicated subject types like Publish, Behavior, Replay, Async, and Unicast subjects to distribute events to multiple observers.

Can I add retry, timeout, and fallback recovery to asynchronous Go event pipelines?

Resilient asynchronous Go event pipelines support retry, timeout, and fallback recovery operators to handle transient failures, combining multiple dependent sources for real-time enrichment while maintaining backpressure-aware processing.

Why does my reactive Go pipeline lose data during backpressure on high-throughput WebSocket ingestion?

Data loss during backpressure on high-throughput WebSocket ingestion occurs when infinite stream pipelines lack proper bounded shutdown and observer error handling, which requires applying backpressure-aware operators and correct subscription lifecycle management.