Programmation fonctionnelle en Go avec IBM fp-go : gestion des erreurs rendue explicite

Les principes de programmation fonctionnelle (FP) gagnent en popularité dans le développement de logiciels modernes en raison de l'accent mis sur l'immuabilité, la composabilité et l'explicitabilité. Alors que Go est traditionnellement un langage impératif, la bibliothèque fp-go, développée par IBM, introduit des abstractions FP telles que Option, Soit, Fold et des utilitaires de composition fonctionnelle. Dans cet article, nous explorerons comment utiliser fp-go pour gérer explicitement les erreurs, définir des signatures de fonction avec plusieurs types d'erreur et créer un exemple d'API CRUD réel illustrant ces concepts.

Pourquoi la gestion des erreurs fonctionnelles ?

La gestion des erreurs est cruciale pour créer un logiciel fiable. La gestion traditionnelle des erreurs Go repose sur le renvoi de valeurs d’erreur, qui peuvent être involontairement ignorées ou mal gérées. La gestion fonctionnelle des erreurs introduit des abstractions telles que :

1. Option : représente des valeurs facultatives, semblables à Some et None dans d'autres langages FP.
2. Soit : encapsule une valeur qui peut être soit une droite (succès), soit une gauche (échec), rendant explicite la propagation des erreurs.
3. Unions balisées : permet aux signatures de fonctions de définir clairement les types d'erreurs possibles.
4. Composition : Permet d'enchaîner les opérations tout en gérant les erreurs naturellement.

Plongeons dans ces concepts et voyons comment fp-go les facilite dans Go.

---

Premiers pas avec fp-go

Tout d'abord, ajoutez fp-go à votre projet Go :

go get github.com/IBM/fp-go

Importez les modules nécessaires :

import (
    either "github.com/IBM/fp-go/either"
    option "github.com/IBM/fp-go/option"
)

---

Option : Gestion des valeurs facultatives

L'option représente une valeur qui peut exister ou non. Il s'agit soit de Certains (valeur), soit d'Aucun.

Exemple : Analyser un entier

func parseInt(input string) option.Option[int] {
    value, err := strconv.Atoi(input)
    if err != nil {
        return option.None[int]()
    }
    return option.Some(value)
}

func main() {
    opt := parseInt("42")

    option.Fold(
        func() { fmt.Println("No value") },
        func(value int) { fmt.Printf("Parsed value: %d\n", value) },
    )(opt)
}

Points clés à retenir :

• L'option élimine les valeurs nulles.
• Fold est utilisé pour gérer les deux cas (Certains ou Aucun).

---

Soit : gérer les erreurs explicitement

L'un ou l'autre représente un calcul qui peut aboutir à deux possibilités :

1. Gauche : représente une erreur.
2. Droit : Représente un résultat réussi.

Exemple : Division sécurisée

type MathError struct {
    Code    string
    Message string
}

func safeDivide(a, b int) either.Either[MathError, int] {
    if b == 0 {
        return either.Left(MathError{Code: "DIV_BY_ZERO", Message: "Cannot divide by zero"})
    }
    return either.Right(a / b)
}

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

    either.Fold(
        func(err MathError) { fmt.Printf("Error [%s]: %s\n", err.Code, err.Message) },
        func(value int) { fmt.Printf("Result: %d\n", value) },
    )(result)
}

Points clés à retenir :

• L’un ou l’autre sépare les chemins du succès et de l’échec.
• Fold simplifie la gestion des deux cas en un seul endroit.

---

Signatures de fonction avec plusieurs types d'erreur

Les applications du monde réel doivent souvent gérer plusieurs types d'erreurs. En utilisant des unions balisées, nous pouvons définir des types d'erreurs explicites.

Exemple : Union marquée pour les erreurs

go get github.com/IBM/fp-go

Avantages:

• Les syndicats étiquetés font des erreurs en s'auto-documentant.
• Les types explicites réduisent l'ambiguïté dans la gestion des erreurs.

---

Exemple concret : API CRUD

Implémentons une API CRUD simple avec une gestion explicite des erreurs à l'aide de l'un ou l'autre.

Définitions des modèles et des erreurs

import (
    either "github.com/IBM/fp-go/either"
    option "github.com/IBM/fp-go/option"
)

Couche de référentiel

func parseInt(input string) option.Option[int] {
    value, err := strconv.Atoi(input)
    if err != nil {
        return option.None[int]()
    }
    return option.Some(value)
}

func main() {
    opt := parseInt("42")

    option.Fold(
        func() { fmt.Println("No value") },
        func(value int) { fmt.Printf("Parsed value: %d\n", value) },
    )(opt)
}

Couche de service

type MathError struct {
    Code    string
    Message string
}

func safeDivide(a, b int) either.Either[MathError, int] {
    if b == 0 {
        return either.Left(MathError{Code: "DIV_BY_ZERO", Message: "Cannot divide by zero"})
    }
    return either.Right(a / b)
}

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

    either.Fold(
        func(err MathError) { fmt.Printf("Error [%s]: %s\n", err.Code, err.Message) },
        func(value int) { fmt.Printf("Result: %d\n", value) },
    )(result)
}

Contrôleur

type AppError struct {
    Tag     string
    Message string
}

const (
    MathErrorTag    = "MathError"
    DatabaseErrorTag = "DatabaseError"
)

func NewMathError(msg string) AppError {
    return AppError{Tag: MathErrorTag, Message: msg}
}

func NewDatabaseError(msg string) AppError {
    return AppError{Tag: DatabaseErrorTag, Message: msg}
}

func process(a, b int) either.Either[AppError, int] {
    if b == 0 {
        return either.Left(NewMathError("Division by zero"))
    }
    return either.Right(a / b)
}

func main() {
    result := process(10, 0)

    either.Fold(
        func(err AppError) { fmt.Printf("Error [%s]: %s\n", err.Tag, err.Message) },
        func(value int) { fmt.Printf("Processed result: %d\n", value) },
    )(result)
}

---

Conclusion

En utilisant fp-go dans Go, nous pouvons :

• Modélisez les erreurs explicitement en utilisant l'un ou l'autre.
• Représentez les valeurs facultatives avec Option.
• Gérez plusieurs types d'erreurs via des unions balisées.
• Créez des API maintenables et composables.

Ces modèles rendent votre code Go plus robuste, lisible et fonctionnel. Que vous construisiez une API CRUD ou une logique métier complexe, fp-go vous permet de gérer les erreurs de manière propre et cohérente.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!