ペルソナ: あなたは Golang エンジニアであり、関数型プログラミングの安全性を Go にもたらします。モナドを使って、不可能な状態を表現不可能にします — nil チェックは型の制約になり、エラーハンドリングは合成可能なパイプラインになります。

思考モード: ultrathink を使用して、複数ステップの Option/Result/Either パイプラインを設計します。型の選択を間違えると、不要なラッピング/アンラッピングが生じ、モナドの目的を損なわせます。

samber/mo — Go のためのモナドと関数型抽象

Go 1.18+ のライブラリで、依存関係なしの型安全なモナド型を提供します。Scala、Rust、fp-ts にインスパイアされています。

公式リソース:

• pkg.go.dev/github.com/samber/mo
• github.com/samber/mo

このスキルはすべてを網羅していません。詳細情報については、ライブラリドキュメントとコード例を参照してください。Context7 は発見プラットフォームとして役立ちます。

go get github.com/samber/mo

関数型プログラミングの概念と、モナドが Go で価値を持つ理由の紹介については、Monads Guide を参照してください。

コア型の概要

型	目的	考え方
Option[T]	存在しない可能性のある値	Rust の Option、Java の Optional
Result[T]	失敗の可能性がある操作	Rust の Result<T, E>、(T, error) の代替
Either[L, R]	2 つの型のいずれか	Scala の Either、TypeScript の判別ユニオン
EitherX[L, R]	X 個の型のいずれか	Scala の Either、TypeScript の判別ユニオン
Future[T]	未来の非同期値	JavaScript の Promise
IO[T]	遅延同期副作用	Haskell の IO
Task[T]	遅延非同期計算	fp-ts の Task
State[S, A]	ステートフルな計算	Haskell の State モナド

Option[T] — nil のないヌル可能値

存在する (Some) または存在しない (None) 値を表します。nil ポインタのリスクを型レベルで排除します。

import "github.com/samber/mo"

name := mo.Some("Alice")          // 値を持つ Option[string]
empty := mo.None[string]()        // 値を持たない Option[string]
fromPtr := mo.PointerToOption(ptr) // nil ポインタ -> None

// 安全な抽出
name.OrElse("Anonymous")  // "Alice"
empty.OrElse("Anonymous")  // "Anonymous"

// 値が存在すれば変換、なければスキップ
upper := name.Map(func(s string) (string, bool) {
    return strings.ToUpper(s), true
})

主要メソッド: Some, None, Get, MustGet, OrElse, OrEmpty, Map, FlatMap, Match, ForEach, ToPointer, IsPresent, IsAbsent.

Option は json.Marshaler/Unmarshaler、sql.Scanner、driver.Valuer を実装しており、JSON 構造体とデータベースモデル内で直接使用できます。

完全な API リファレンスについては、Option Reference を参照してください。

Result[T] — 値としてのエラーハンドリング

成功 (Ok) または失敗 (Err) を表します。Either[error, T] と等価ですが、Go のエラーパターン用に特化しています。

// Go の (value, error) パターンをラップ
result := mo.TupleToResult(os.ReadFile("config.yaml"))

// 同一型の変換 — エラーは自動的にショートサーキット
upper := mo.Ok("hello").Map(func(s string) (string, error) {
    return strings.ToUpper(s), nil
})
// Ok("HELLO")

// フォールバック付きで抽出
val := upper.OrElse("default")

Go の制限: 直接メソッド (.Map, .FlatMap) は型パラメータを変更できません — Result[T].Map は Result[U] ではなく Result[T] を返します。Go メソッドは新しい型パラメータを導入できません。型変更変換 (例: Result[[]byte] から Result[Config] へ) の場合は、サブパッケージ関数または mo.Do を使用します:

import "github.com/samber/mo/result"

// 型変更パイプライン: []byte -> Config -> ValidConfig
parsed := result.Pipe2(
    mo.TupleToResult(os.ReadFile("config.yaml")),
    result.Map(func(data []byte) Config { return parseConfig(data) }),
    result.FlatMap(func(cfg Config) mo.Result[ValidConfig] { return validate(cfg) }),
)

主要メソッド: Ok, Err, Errf, TupleToResult, Try, Get, MustGet, OrElse, Map, FlatMap, MapErr, Match, ForEach, ToEither, IsOk, IsError.

完全な API リファレンスについては、Result Reference を参照してください。

Either[L, R] — 2 つの型の判別ユニオン

2 つの可能な型のいずれかの値を表します。Result と異なり、どちらのサイドも成功/失敗を暗示しません — 両方とも有効な選択肢です。

// キャッシュデータまたは新鮮なデータのいずれかを返す API
func fetchUser(id string) mo.Either[CachedUser, FreshUser] {
    if cached, ok := cache.Get(id); ok {
        return mo.Left[CachedUser, FreshUser](cached)
    }
    return mo.Right[CachedUser, FreshUser](db.Fetch(id))
}

// パターンマッチング
result.Match(
    func(cached CachedUser) mo.Either[CachedUser, FreshUser] { /* キャッシュを使用 */ },
    func(fresh FreshUser) mo.Either[CachedUser, FreshUser] { /* 新鮮なデータを使用 */ },
)

Either vs Result を使い分ける: 一方のパスがエラーの場合は Result[T] を使用します。両方のパスが有効な選択肢である場合 (キャッシュ vs 新鮮、左 vs 右、戦略 A vs B) は Either[L, R] を使用します。

Either3[T1, T2, T3]、Either4、Either5 はこれを 3～5 個の型バリアントに拡張します。

完全な API リファレンスについては、Either Reference を参照してください。

Do 記法 — モナド安全性を備えた命令型スタイル

mo.Do は命令型コードを Result でラップし、MustGet() 呼び出しからのパニックをキャッチします:

result := mo.Do(func() int {
    // MustGet は None/Err でパニック — Do はそれを Result エラーとしてキャッチ
    a := mo.Some(21).MustGet()
    b := mo.Ok(2).MustGet()
    return a * b  // 42
})
// result は Ok(42)

result := mo.Do(func() int {
    val := mo.None[int]().MustGet()  // パニック
    return val
})
// result は Err("no such element")

Do 記法は命令型 Go スタイルをモナド安全性とブリッジします — ストレートラインコードを書けば、自動的なエラー伝播が得られます。

パイプラインサブパッケージ vs 直接チェーン

samber/mo は操作を合成する 2 つの方法を提供します:

直接メソッド (.Map, .FlatMap) — 出力型が入力型と等しい場合に機能:

opt := mo.Some(42)
doubled := opt.Map(func(v int) (int, bool) {
    return v * 2, true
})  // Option[int]

サブパッケージ関数 (option.Map, result.Map) — 出力型が入力型と異なる場合に必須:

import "github.com/samber/mo/option"

// int -> string 型変更: サブパッケージ Map を使用
strOpt := option.Map(func(v int) string {
    return fmt.Sprintf("value: %d", v)
})(mo.Some(42))  // Option[string]

Pipe 関数 (option.Pipe3, result.Pipe3) — 複数の型変更変換を読みやすくチェーン:

import "github.com/samber/mo/option"

result := option.Pipe3(
    mo.Some(42),
    option.Map(func(v int) string { return strconv.Itoa(v) }),
    option.Map(func(s string) []byte { return []byte(s) }),
    option.FlatMap(func(b []byte) mo.Option[string] {
        if len(b) > 0 { return mo.Some(string(b)) }
        return mo.None[string]()
    }),
)

経験則: 同一型の変換には直接メソッドを使用します。ステップ全体で型が変わる場合はサブパッケージ関数 + パイプを使用します。

詳細なパイプライン API リファレンスについては、Pipelines Reference を参照してください。

一般的なパターン

Option を使った JSON API レスポンス

type UserResponse struct {
    Name     string            `json:"name"`
    Nickname mo.Option[string] `json:"nickname"`  // null を優雅に省略
    Bio      mo.Option[string] `json:"bio"`
}

データベース nullable カラム

type User struct {
    ID       int
    Email    string
    Phone    mo.Option[string]  // sql.Scanner + driver.Valuer を実装
}

err := row.Scan(&u.ID, &u.Email, &u.Phone)

既存 Go API のラッピング

// マップルックアップを Option に変換
func MapGet[K comparable, V any](m map[K]V, key K) mo.Option[V] {
    return mo.TupleToOption(m[key])  // m[key] は (V, bool) を返す
}

Fold を使った統一抽出

mo.Fold は Foldable インターフェースを経由して Option、Result、Either に統一的に機能します:

str := mo.Fold[error, int, string](
    mo.Ok(42),  // Option、Result、Either で機能
    func(v int) string { return fmt.Sprintf("got %d", v) },
    func(err error) string { return "failed" },
)
// "got 42"

ベストプラクティス

1. MustGet より OrElse を優先 — MustGet は欠落/エラー値でパニックします。mo.Do ブロック内でのみ使用するか、値が確実に存在する場合に使用してください
2. API の境界で TupleToResult を使用 — Go の (T, error) を境界で Result[T] に変換し、次にドメインロジック内で Map/FlatMap でチェーン
3. エラーは Result[T]、選択肢は Either[L, R] を使用 — Result は成功/失敗用に特化。Either は 2 つの有効な型用です
4. Option をヌル可能フィールドに、ゼロ値には使用しない — Option[string] は「欠落」と「空文字列」を区別します。空文字列が有効な値の場合は plain string を使用してください
5. ネストではなくチェーン — result.Map(...).FlatMap(...).OrElse(default) は左から右に読みやすい。モナドチェーンがより読みやすい場合はネストした if/else パターンを避けてください
6. 複数ステップの型変更には Pipe を使用 — 3+ ステップで各ステップが型を変更する場合、option.Pipe3(...) はネストした関数呼び出しより読みやすい

高度な型 (Future、IO、Task、State) については、Advanced Types Reference を参照してください。

samber/mo でバグや予期しない動作が発生した場合は、https://github.com/samber/mo/issues で issue をオープンしてください。

クロスリファレンス

• -> samber/cc-skills-golang@golang-samber-lo スキルを参照してください。関数型コレクション変換 (スライスの Map、Filter、Reduce) で mo 型と合成
• -> samber/cc-skills-golang@golang-error-handling スキルを参照してください。慣例的な Go エラーハンドリングパターン
• -> samber/cc-skills-golang@golang-safety スキルを参照してください。nil 安全性と防御的な Go コーディング
• -> samber/cc-skills-golang@golang-database スキルを参照してください。データベースアクセスパターン
• -> samber/cc-skills-golang@golang-design-patterns スキルを参照してください。関数型オプションと他の Go パターン