Bibliothèque `mo` pour Go : Monades et patrons fonctionnels

Bienvenue dans l'univers de la programmation fonctionnelle en Go ! La bibliothèque mo (pour monads) est un outil puissant qui apporte au langage impératif Go les concepts de monades et de patrons fonctionnels, populaires en Haskell, Scala et Rust. Si vous avez déjà été confronté à la gestion d'erreurs avec if err != nil, aux vérifications infinies de nil ou aux chaînes d'appels complexes, mo offre une solution élégante.

L'objectif principal de la bibliothèque est de fournir des conteneurs type-safe (Option, Result, Either) qui encapsulent les états possibles (présence/absence de valeur, succès/erreur) et permettent de les manipuler de manière fonctionnelle. Au lieu d'écrire des dizaines de conditions, vous construisez des chaînes de transformations où chaque étape est gérée automatiquement. Cela rend le code plus lisible, plus prévisible et moins sujet aux erreurs, en particulier dans les logiques métier complexes.

La bibliothèque mo ne cherche pas à transformer Go en Haskell. Elle propose une approche pragmatique : vous utilisez les patrons fonctionnels là où ils simplifient vraiment le code, tout en conservant la syntaxe familière de Go. mo est particulièrement utile pour la gestion des erreurs, le travail avec les valeurs optionnelles, la composition de fonctions et l'implémentation de pipelines de traitement de données. Elle s'intègre bien avec les goroutines et les canaux, permettant de construire des programmes concurrents fiables.

Installation

L'installation de la bibliothèque mo se fait de manière standard pour Go via le gestionnaire de paquets go get. Exécutez la commande suivante dans votre terminal à la racine de votre projet (là où se trouve le fichier go.mod) :

go get github.com/samber/mo

Après avoir exécuté cette commande, la bibliothèque sera ajoutée à votre fichier go.mod et vous pourrez l'importer dans vos fichiers sources. Assurez-vous d'avoir installé Go version 1.18 ou supérieure (nécessaire pour la prise en charge des generics).

Démarrage rapide

Commençons par un exemple classique : la division sécurisée de deux nombres. En Go traditionnel, nous renverrions une erreur. Avec mo, nous utilisons le type Result, qui peut être soit Ok (succès), soit Err (erreur).

package main

import (
    "fmt"
    "github.com/samber/mo"
)

// safeDivide retourne un Result qui contient soit le résultat de la division, soit une erreur.
func safeDivide(a, b float64) mo.Result[float64] {
    if b == 0 {
        return mo.Err[float64](fmt.Errorf("division par zéro"))
    }
    return mo.Ok(a / b)
}

func main() {
    result := safeDivide(10, 2)

    // Utilisation de la méthode Match pour traiter les deux cas.
    result.Match(
        func(value float64) {
            fmt.Printf("Résultat : %.2f\n", value)
        },
        func(err error) {
            fmt.Printf("Erreur : %s\n", err)
        },
    )

    // Essayons une division par zéro.
    result2 := safeDivide(10, 0)
    result2.Match(
        func(value float64) {
            fmt.Printf("Résultat : %.2f\n", value)
        },
        func(err error) {
            fmt.Printf("Erreur : %s\n", err)
        },
    )
}

Cet exemple illustre l'idée de base : au lieu de vérifier l'erreur manuellement, nous déléguons la responsabilité du traitement à la bibliothèque en utilisant la méthode Match.