Introduction à la programmation fonctionnelle en JavaScript : applicatifs #10

Les applicatifs offrent un moyen puissant et expressif de travailler avec des fonctions et des structures de données qui impliquent du contexte, telles que des valeurs facultatives, des calculs asynchrones ou des listes. Les applicatifs étendent le concept de foncteurs, permettant l'application de fonctions enveloppées dans un contexte à des valeurs également enveloppées dans un contexte.

Qu'est-ce qu'un applicatif ?

Un applicatif est un type de foncteur qui prend non seulement en charge le mappage d'une fonction sur une valeur encapsulée (comme un foncteur), mais permet également d'appliquer des fonctions elles-mêmes encapsulées dans un contexte à des valeurs qui sont encapsulées dans un contexte. Les applicatifs fournissent un moyen de gérer des opérations impliquant plusieurs valeurs fonctionnelles.

Propriétés des applicatifs

1. Identité : l'application d'une fonction d'identité encapsulée à une valeur encapsulée devrait donner la valeur encapsulée. [ texte{A.of(x).ap(A.of(f))} texte équivalent{A.of(f(x))} ]
2. Homomorphisme : L'application d'une fonction encapsulée à une valeur encapsulée devrait produire le même résultat que l'application de la fonction à la valeur puis son habillage. [ texte{A.of(f).ap(A.of(x))} texte équivalent{A.of(f(x))} ]
3. Interchange : Appliquer une fonction encapsulée à une valeur encapsulée devrait être équivalent à appliquer la valeur encapsulée à une fonction qui applique la fonction encapsulée. [ texte{A.of(f).ap(u)} équivalent texte{u.ap(A.of(f => f(x)))} ]

Implémentation d'applicatifs en JavaScript

Explorons comment implémenter et utiliser des applicatifs en JavaScript.

Exemple : implémentation de Maybe en tant qu'applicatif

Le type Peut-être est souvent utilisé pour représenter des valeurs facultatives. Étendons Maybe pour prendre en charge les opérations applicatives.

class Maybe {
  constructor(value) {
    this.value = value;
  }

  static of(value) {
    return new Maybe(value);
  }

  map(fn) {
    return this.value === null || this.value === undefined
      ? Maybe.of(null)
      : Maybe.of(fn(this.value));
  }

  ap(maybe) {
    return this.value === null || this.value === undefined
      ? Maybe.of(null)
      : maybe.map(this.value);
  }
}

// Usage
const add = (a) => (b) => a + b;

const maybeAdd = Maybe.of(add);
const maybeTwo = Maybe.of(2);
const maybeThree = Maybe.of(3);

const result = maybeAdd.ap(maybeTwo).ap(maybeThree);
console.log(result); // Maybe { value: 5 }

Dans cet exemple, Maybe implémente la méthode ap, qui applique une fonction enveloppée dans un contexte Maybe à une valeur enveloppée dans un autre contexte Maybe. Cela permet d'enchaîner des opérations impliquant des valeurs facultatives.

Travailler avec des applicatifs en pratique

Les applicatifs sont particulièrement utiles lorsqu'il s'agit de calculs impliquant plusieurs contextes, tels que la combinaison de plusieurs opérations asynchrones ou la gestion de plusieurs valeurs facultatives.

Exemple : combiner plusieurs promesses

Voyons comment les applicatifs peuvent aider à combiner plusieurs promesses.

const fetchData = (url) => {
  return new Promise((resolve) => {
    setTimeout(() => {
      resolve(`Data from ${url}`);
    }, 1000);
  });
};

const add = (a) => (b) => a + b;

const promiseAdd = Promise.resolve(add);
const promiseTwo = fetchData('url1').then((data) => parseInt(data.split(' ')[2]));
const promiseThree = fetchData('url2').then((data) => parseInt(data.split(' ')[2]));

const result = promiseAdd
  .then((fn) => promiseTwo.then((a) => fn(a)))
  .then((fn) => promiseThree.then((b) => fn(b)));

result.then(console.log); // Output after 2 seconds: NaN (since "from" cannot be parsed as an int)

Dans cet exemple, nous combinons plusieurs promesses en utilisant le modèle applicatif. Bien que l'exemple présente un problème logique avec l'analyse, il montre comment les applicatifs peuvent être utilisés pour séquencer des opérations qui impliquent le contexte.

Exemple : gestion de plusieurs valeurs facultatives

Les applicatifs sont également utiles pour combiner plusieurs valeurs facultatives.

const add = (a) => (b) => a + b;

const maybeAdd = Maybe.of(add);
const maybeFive = Maybe.of(5);
const maybeNull = Maybe.of(null);

const result1 = maybeAdd.ap(maybeFive).ap(maybeFive); // Maybe { value: 10 }
const result2 = maybeAdd.ap(maybeFive).ap(maybeNull); // Maybe { value: null }

console.log(result1); // Maybe { value: 10 }
console.log(result2); // Maybe { value: null }

Dans cet exemple, nous utilisons le modèle applicatif pour combiner plusieurs valeurs Maybe, en gérant gracieusement la présence de null.

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!