Golang Samber Mo

1---2name: golang-samber-mo3description: "Monadic types for Golang using samber/mo — Option, Result, Either, Future, IO, Task, and State types for type-safe nullable values, error handling, and functional composition with pipeline sub-packages. Apply when using or adopting samber/mo, when the codebase imports `github.com/samber/mo`, or when considering functional programming patterns as a safety design for Golang."4user-invocable: true5license: MIT6compatibility: Designed for Claude Code or similar AI coding agents, and for projects using Golang.7metadata:8  author: samber9  version: "1.0.3"10  openclaw:11    emoji: "🎭"12    homepage: https://github.com/samber/cc-skills-golang13    requires:14      bins:15        - go16    install: []17    skill-library-version: "1.16.0"18allowed-tools: Read Edit Write Glob Grep Bash(go:*) Bash(golangci-lint:*) Bash(git:*) Agent WebFetch mcp__context7__resolve-library-id mcp__context7__query-docs AskUserQuestion19---20 21**Persona:** You are a Go engineer bringing functional programming safety to Go. You use monads to make impossible states unrepresentable — nil checks become type constraints, error handling becomes composable pipelines.22 23**Thinking mode:** Use `ultrathink` when designing multi-step Option/Result/Either pipelines. Wrong type choice creates unnecessary wrapping/unwrapping that defeats the purpose of monads.24 25# samber/mo — Monads and Functional Abstractions for Go26 27Go 1.18+ library providing type-safe monadic types with zero dependencies. Inspired by Scala, Rust, and fp-ts.28 29**Official Resources:**30 31- [pkg.go.dev/github.com/samber/mo](https://pkg.go.dev/github.com/samber/mo)32- [github.com/samber/mo](https://github.com/samber/mo)33 34This skill is not exhaustive. Please refer to library documentation and code examples for more information. Context7 can help as a discoverability platform.35 36```bash37go get github.com/samber/mo38```39 40For an introduction to functional programming concepts and why monads are valuable in Go, see [Monads Guide](./references/monads-guide.md).41 42## Core Types at a Glance43 44| Type | Purpose | Think of it as... |45| --- | --- | --- |46| `Option[T]` | Value that may be absent | Rust's `Option`, Java's `Optional` |47| `Result[T]` | Operation that may fail | Rust's `Result<T, E>`, replaces `(T, error)` |48| `Either[L, R]` | Value of one of two types | Scala's `Either`, TypeScript discriminated union |49| `EitherX[L, R]` | Value of one of X types | Scala's `Either`, TypeScript discriminated union |50| `Future[T]` | Async value not yet available | JavaScript `Promise` |51| `IO[T]` | Lazy synchronous side effect | Haskell's `IO` |52| `Task[T]` | Lazy async computation | fp-ts `Task` |53| `State[S, A]` | Stateful computation | Haskell's `State` monad |54 55## Option[T] — Nullable Values Without nil56 57Represents a value that is either present (`Some`) or absent (`None`). Eliminates nil pointer risks at the type level.58 59```go60import "github.com/samber/mo"61 62name := mo.Some("Alice")          // Option[string] with value63empty := mo.None[string]()        // Option[string] without value64fromPtr := mo.PointerToOption(ptr) // nil pointer -> None65 66// Safe extraction67name.OrElse("Anonymous")  // "Alice"68empty.OrElse("Anonymous")  // "Anonymous"69 70// Transform if present, skip if absent71upper := name.Map(func(s string) (string, bool) {72    return strings.ToUpper(s), true73})74```75 76**Key methods:** `Some`, `None`, `Get`, `MustGet`, `OrElse`, `OrEmpty`, `Map`, `FlatMap`, `Match`, `ForEach`, `ToPointer`, `IsPresent`, `IsAbsent`.77 78Option implements `json.Marshaler/Unmarshaler`, `sql.Scanner`, `driver.Valuer` — use it directly in JSON structs and database models.79 80For full API reference, see [Option Reference](./references/option.md).81 82## Result[T] — Error Handling as Values83 84Represents success (`Ok`) or failure (`Err`). Equivalent to `Either[error, T]` but specialized for Go's error pattern.85 86```go87// Wrap Go's (value, error) pattern88result := mo.TupleToResult(os.ReadFile("config.yaml"))89 90// Same-type transform — errors short-circuit automatically91upper := mo.Ok("hello").Map(func(s string) (string, error) {92    return strings.ToUpper(s), nil93})94// Ok("HELLO")95 96// Extract with fallback97val := upper.OrElse("default")98```99 100**Go limitation:** Direct methods (`.Map`, `.FlatMap`) cannot change the type parameter — `Result[T].Map` returns `Result[T]`, not `Result[U]`. Go methods cannot introduce new type parameters. For type-changing transforms (e.g. `Result[[]byte]` to `Result[Config]`), use sub-package functions or `mo.Do`:101 102```go103import "github.com/samber/mo/result"104 105// Type-changing pipeline: []byte -> Config -> ValidConfig106parsed := result.Pipe2(107    mo.TupleToResult(os.ReadFile("config.yaml")),108    result.Map(func(data []byte) Config { return parseConfig(data) }),109    result.FlatMap(func(cfg Config) mo.Result[ValidConfig] { return validate(cfg) }),110)111```112 113**Key methods:** `Ok`, `Err`, `Errf`, `TupleToResult`, `Try`, `Get`, `MustGet`, `OrElse`, `Map`, `FlatMap`, `MapErr`, `Match`, `ForEach`, `ToEither`, `IsOk`, `IsError`.114 115For full API reference, see [Result Reference](./references/result.md).116 117## Either[L, R] — Discriminated Union of Two Types118 119Represents a value that is one of two possible types. Unlike Result, neither side implies success or failure — both are valid alternatives.120 121```go122// API that returns either cached data or fresh data123func fetchUser(id string) mo.Either[CachedUser, FreshUser] {124    if cached, ok := cache.Get(id); ok {125        return mo.Left[CachedUser, FreshUser](cached)126    }127    return mo.Right[CachedUser, FreshUser](db.Fetch(id))128}129 130// Pattern match131result.Match(132    func(cached CachedUser) mo.Either[CachedUser, FreshUser] { /* use cached */ },133    func(fresh FreshUser) mo.Either[CachedUser, FreshUser] { /* use fresh */ },134)135```136 137**When to use Either vs Result:** Use `Result[T]` when one path is an error. Use `Either[L, R]` when both paths are valid alternatives (cached vs fresh, left vs right, strategy A vs B).138 139`Either3[T1, T2, T3]`, `Either4`, and `Either5` extend this to 3-5 type variants.140 141For full API reference, see [Either Reference](./references/either.md).142 143## Do Notation — Imperative Style with Monadic Safety144 145`mo.Do` wraps imperative code in a `Result`, catching panics from `MustGet()` calls:146 147```go148result := mo.Do(func() int {149    // MustGet panics on None/Err — Do catches it as Result error150    a := mo.Some(21).MustGet()151    b := mo.Ok(2).MustGet()152    return a * b  // 42153})154// result is Ok(42)155 156result := mo.Do(func() int {157    val := mo.None[int]().MustGet()  // panics158    return val159})160// result is Err("no such element")161```162 163Do notation bridges imperative Go style with monadic safety — write straight-line code, get automatic error propagation.164 165## Pipeline Sub-Packages vs Direct Chaining166 167samber/mo provides two ways to compose operations:168 169**Direct methods** (`.Map`, `.FlatMap`) — work when the output type equals the input type:170 171```go172opt := mo.Some(42)173doubled := opt.Map(func(v int) (int, bool) {174    return v * 2, true175})  // Option[int]176```177 178**Sub-package functions** (`option.Map`, `result.Map`) — required when the output type differs from input:179 180```go181import "github.com/samber/mo/option"182 183// int -> string type change: use sub-package Map184strOpt := option.Map(func(v int) string {185    return fmt.Sprintf("value: %d", v)186})(mo.Some(42))  // Option[string]187```188 189**Pipe functions** (`option.Pipe3`, `result.Pipe3`) — chain multiple type-changing transformations readably:190 191```go192import "github.com/samber/mo/option"193 194result := option.Pipe3(195    mo.Some(42),196    option.Map(func(v int) string { return strconv.Itoa(v) }),197    option.Map(func(s string) []byte { return []byte(s) }),198    option.FlatMap(func(b []byte) mo.Option[string] {199        if len(b) > 0 { return mo.Some(string(b)) }200        return mo.None[string]()201    }),202)203```204 205**Rule of thumb:** Use direct methods for same-type transforms. Use sub-package functions + pipes when types change across steps.206 207For detailed pipeline API reference, see [Pipelines Reference](./references/pipelines.md).208 209## Common Patterns210 211### JSON API responses with Option212 213```go214type UserResponse struct {215    Name     string            `json:"name"`216    Nickname mo.Option[string] `json:"nickname"`  // omits null gracefully217    Bio      mo.Option[string] `json:"bio"`218}219```220 221### Database nullable columns222 223```go224type User struct {225    ID       int226    Email    string227    Phone    mo.Option[string]  // implements sql.Scanner + driver.Valuer228}229 230err := row.Scan(&u.ID, &u.Email, &u.Phone)231```232 233### Wrapping existing Go APIs234 235```go236// Convert map lookup to Option237func MapGet[K comparable, V any](m map[K]V, key K) mo.Option[V] {238    return mo.TupleToOption(m[key])  // m[key] returns (V, bool)239}240```241 242### Uniform extraction with Fold243 244`mo.Fold` works uniformly across Option, Result, and Either via the `Foldable` interface:245 246```go247str := mo.Fold[error, int, string](248    mo.Ok(42),  // works with Option, Result, or Either249    func(v int) string { return fmt.Sprintf("got %d", v) },250    func(err error) string { return "failed" },251)252// "got 42"253```254 255## Best Practices256 2571. **Prefer `OrElse` over `MustGet`** — `MustGet` panics on absent/error values; use it only inside `mo.Do` blocks where panics are caught, or when you are certain the value exists2582. **Use `TupleToResult` at API boundaries** — convert Go's `(T, error)` to `Result[T]` at the boundary, then chain with `Map`/`FlatMap` inside your domain logic2593. **Use `Result[T]` for errors, `Either[L, R]` for alternatives** — Result is specialized for success/failure; Either is for two valid types2604. **Option for nullable fields, not zero values** — `Option[string]` distinguishes "absent" from "empty string"; use plain `string` when empty string is a valid value2615. **Chain, don't nest** — `result.Map(...).FlatMap(...).OrElse(default)` reads left-to-right; avoid nested if/else patterns when monadic chaining is cleaner2626. **Use sub-package pipes for multi-step type transformations** — when 3+ steps each change the type, `option.Pipe3(...)` is more readable than nested function calls263 264For advanced types (Future, IO, Task, State), see [Advanced Types Reference](./references/advanced-types.md).265 266If you encounter a bug or unexpected behavior in samber/mo, open an issue at <https://github.com/samber/mo/issues>.267 268## Cross-References269 270- -> See `samber/cc-skills-golang@golang-samber-lo` skill for functional collection transforms (Map, Filter, Reduce on slices) that compose with mo types271- -> See `samber/cc-skills-golang@golang-error-handling` skill for idiomatic Go error handling patterns272- -> See `samber/cc-skills-golang@golang-safety` skill for nil-safety and defensive Go coding273- -> See `samber/cc-skills-golang@golang-database` skill for database access patterns274- -> See `samber/cc-skills-golang@golang-design-patterns` skill for functional options and other Go patterns