Programmation fonctionnelle en Go : techniques avancées et exemples

Programmation fonctionnelle en Go : techniques avancées et exemples

Go (Golang) n'a pas été conçu à l'origine comme un langage purement fonctionnel, cependant ses puissantes capacités, telles que les fermetures, les fonctions de première classe et les goroutines, permettent d'appliquer avec succès le paradigme de la programmation fonctionnelle (PF) à un niveau avancé. Cet article est destiné aux développeurs déjà familiers avec les bases de Go et souhaitant approfondir les techniques fonctionnelles pour écrire un code plus prévisible, testable et parallèle. Nous aborderons la curryfication, la composition de fonctions, le travail avec des structures de type monade et l'intégration de la PF avec les goroutines.

1. Curryfication et application partielle des fonctions

La curryfication est la transformation d'une fonction qui prend plusieurs arguments en une séquence de fonctions, chacune prenant un seul argument. En Go, où il n'y a pas de support natif pour la curryfication, nous l'implémentons via des fermetures.

Exemple : curryfication pour un logger configurable

package main

import "fmt"

// Fonction curryfiée : préfixe -> message -> sortiefunc createLogger(prefix string) func(string) {    return func(message string) {        fmt.Printf("[%s] %s", prefix, message)    }}

func main() {    infoLogger := createLogger("INFO")    errorLogger := createLogger("ERREUR")

    infoLogger("Système démarré")    errorLogger("Erreur de connexion")    // Sortie :    // [INFO] Système démarré    // [ERREUR] Erreur de connexion}

L'application partielle est un cas particulier de curryfication, où nous fixons une partie des arguments. En Go, cela est particulièrement utile pour créer des versions spécialisées de fonctions.

// Application partielle : fixation du coefficientfunc multiply(a, b int) int {    return a * b}

func partialMultiply(a int) func(int) int {    return func(b int) int {        return multiply(a, b)    }}

func main() {    double := partialMultiply(2)    triple := partialMultiply(3)

    fmt.Println(double(5)) // 10    fmt.Println(triple(5)) // 15}

2. Composition de fonctions et pipelines

La composition est l'association de fonctions simples en fonctions plus complexes. En Go, nous pouvons construire des chaînes de transformations en passant le résultat d'une fonction à l'entrée d'une autre. Cela est particulièrement puissant en combinaison avec les interfaces et les génériques (Go 1.18+).

Exemple : composition pour le traitement de chaînes

package main

import (    "fmt"    "strings"    "unicode")

type StringTransform func(string) string

// Compose crée la composition de deux fonctionsfunc Compose(f, g StringTransform) StringTransform {    return func(s string) string {        return f(g(s))    }}

// Pipeline combine plusieurs fonctionsfunc Pipeline(transforms ...StringTransform) StringTransform {    return func(s string) string {        for _, t := range transforms {            s = t(s)        }        return s    }}

func removeSpaces(s string) string {    return strings.ReplaceAll(s, " ", "")}

func toUpper(s string) string {    return strings.ToUpper(s)}

func removeDigits(s string) string {    var result strings.Builder    for _, r := range s {        if !unicode.IsDigit(r) {            result.WriteRune(r)        }    }    return result.String()}

func main() {    // Composition de deux fonctions    cleanAndUpper := Compose(removeSpaces, toUpper)    result1 := cleanAndUpper("go 1.18 rocks")    fmt.Println(result1) // "GO1.18ROCKS"

    // Pipeline de trois fonctions    pipeline := Pipeline(removeSpaces, removeDigits, toUpper)    result2 := pipeline("go 1.18 rocks")    fmt.Println(result2) // "GOROCKS"}

Cette approche permet de construire des transformations complexes à partir de blocs simples et testables. Chaque fonction du pipeline peut être testée individuellement.

3. Structures de type monade : trav