Préface du traducteur xvii
Avis du lecteur bêta xix
Recommandation 21
Préface xxvi
Remerciements xxviii
À propos de ce livre xxx

CHAPITRE 1 Bienvenue dans le monde de la programmation fonctionnelle : un guide simple pour apprendre

Qu'est-ce que la programmation fonctionnelle ? 2
Problèmes liés aux définitions de la programmation fonctionnelle d'un point de vue pratique 3
Les définitions de la programmation fonctionnelle déroutent les gestionnaires 4
5. Considérer la programmation fonctionnelle comme une technique et un concept, et non comme un savoir académique
Distinguer les actions, les calculs et les données 6
Les programmeurs fonctionnels font la distinction entre le code qui doit être appelé avec prudence 7
Les programmeurs fonctionnels font la distinction entre le code qui s'exécute et le code qui ne s'exécute pas.
Les programmeurs fonctionnels séparent les actions, les calculs et les données. 9
En programmation fonctionnelle, le code est divisé en trois catégories : 10
Quels sont les avantages de séparer les actions, les calculs et les données ? 11
12 différences entre ce livre et d'autres ouvrages sur la programmation fonctionnelle
Qu’est-ce que la pensée fonctionnelle ? 13
14 règles de base pour lire ce livre
Conclusion 16

CHAPITRE 2 La pensée fonctionnelle dans la vie réelle 17

Bienvenue chez Tony's Pizza 18
Partie I : Actions et calculs, Données 19
Code divisé par la capacité de modification 20
Partie II : Abstraction de première classe 21
Visualisation des systèmes distribués sous forme de chronologie 22
Chaque chronologie se déroule dans un ordre différent. 23
24 leçons tirées de l'expérience sur les systèmes distribués
Réduction du temps : Faire attendre les robots les uns les autres 25
26 choses que j'ai apprises sur les chronologies grâce à une bonne expérience
Conclusion 27

PARTIE I Actions, calculs et données

CHAPITRE 3 Comprendre la différence entre actions, calculs et données 31

Actions et calculs, données 32
Les actions, les calculs et les données peuvent être appliqués n'importe où 33
36 choses que j'ai apprises en faisant du shopping
Application de la pensée fonctionnelle au nouveau code 39
Schéma du processus d'envoi des coupons 42
Mise en œuvre du processus d'envoi de coupons 47
Application de la pensée fonctionnelle au code existant 54
Actions réparties dans tout le code 56
L'action prend de nombreuses formes 57
Conclusion 59

CHAPITRE 4 Éliminer les calculs des actions 61

Bienvenue sur MegaMart.com 62
Calculer les frais de livraison gratuite 63
Calcul des impôts 64
Faciliter les tests 65
Faciliter la réutilisation 66
Séparation des actions, des calculs et des données 67
Les fonctions ont des entrées et des sorties 68
Les tests et la réutilisabilité sont liés aux entrées/sorties 69
Mise hors service des calculs 70
En supprimant un autre calcul 73
Examinons le code 85 dans son intégralité.
Conclusion 86

CHAPITRE 5 CRÉER DE MEILLEURES ACTIONS 87

Alignement des exigences commerciales avec la conception 88
Alignement des exigences et des fonctions de l'entreprise 89
Principe : Moins il y a d'entrées et de sorties implicites, mieux c'est. 91
Réduction des entrées et sorties implicites 92
Réexamen du Code 95
Classification des calculs 97
Principe : Concevoir, c'est démêler le code 98
Séparer add_item() pour créer une meilleure conception 99
Extraction du modèle de copie sur écriture 100
Utilisation de add_item() 101
Classification des calculs 102
Petites fonctions et nombreux calculs 106
Conclusion 107

CHAPITRE 6 Maintien de l'immuabilité dans les langages avec des structures de données mutables 109

Toutes les actions peuvent-elles être rendues invariantes ? 110
Classification des actions comme lecture, écriture ou les deux 111
Le principe de la copie sur écriture : trois étapes 112
Conversion de l'écriture en lecture avec Copy-On-Write 113
Afficher les différences entre la version originale et la version copy-on-write 117
L'opération de copie sur écriture que nous avons créée précédemment est courante 118
Aperçu des tableaux JavaScript 119
Comment lire en écrivant ? 122
Séparation des fonctions lues pendant l'écriture 123
Créez une fonction qui renvoie deux valeurs : 124
La lecture des structures de données immuables est un calcul 131
L'application possède un état qui évolue au fil du temps 132
Les structures de données immuables sont suffisamment rapides 133
Copie sur écriture pour les objets 134
Aperçu rapide des objets JavaScript 135
Conversion des écritures imbriquées en lectures 140
De quel type de copie s'agirait-il ? 141
Exploration picturale de la copie superficielle et du partage structurel 142
Conclusion 145

CHAPITRE 7 Maintien de l'invariance lors de l'écriture de code non fiable 147

Code hérité et immuabilité 148
Le code à copie sur écriture que nous créons doit interagir avec du code non fiable. 149
La copie défensive empêche la modification de l'original. 150
Mise en œuvre de la copie défensive 151
Règle 152 de la copie défensive
Encapsulation de code non fiable 153
La copie défensive vous est peut-être familière 156
Comparons la copie à l'écriture et la copie défensive 158
Les copies profondes sont plus chères que les copies superficielles 159
La mise en œuvre de copies profondes en JavaScript est difficile.
Dialogue entre la copie sur support papier et la copie défensive 162
Conclusion 165

CHAPITRE 8 CONCEPTION HIÉRARCHIQUE I 167

Qu'est-ce que la conception logicielle ? 168
Qu’est-ce qu’une conception hiérarchique ? 169
Développer le sens du design 170
Modèle de conception hiérarchique 171
Modèle 1 : Implémentation directe 172
Niveau de zoom en 3 étapes 186
Suppression des boucles 189
Revue du modèle d'implémentation directe 198
Conclusion 199

CHAPITRE 9 CONCEPTION HIÉRARCHIQUE II 201

Modèle de conception hiérarchique 202
Motif 2 : Mur abstrait 203
Dissimuler l'implémentation derrière un mur d'abstraction 204
Les détails cachés sont symétriques 205
Modification de la structure des données du panier d'achat 206
Recréer le panier d'achat en tant qu'objet 208
Avec un mur d'abstraction, vous n'avez pas à vous soucier des détails. 209
Quand est-il judicieux d'utiliser un mur abstrait ? 210
Analyse du motif 2 : Mur abstrait 211
Le code précédemment modifié se rapproche davantage d'une implémentation directe 212
Modèle 3 : Petite interface 213
Analyse du modèle 3 : Petite interface 219
Modèle 4 : Couche pratique 220
Modèle de conception hiérarchique 221
Quelles informations sur le code peut-on tirer du graphique ? 222
Le code en haut du graphique est le plus facile à corriger : 223
Le code ci-dessous est important pour tester 225
Le code ci-dessous est plus facile à réutiliser. 228
Résumé : Ce que le graphique vous apprend sur votre code 229
Conclusion 230

PARTIE II Résumé de première classe

CHAPITRE 10 : Fonctions de première classe I 233

L'équipe marketing doit encore consulter l'équipe de développement 235
Mauvaises pratiques de programmation : arguments implicites dans les noms de fonctions 236
Refactorisation : Mise en évidence des arguments implicites 238
Distinction entre les billets de première classe et les billets de classe inférieure 240
L'utilisation de noms de champs sous forme de chaînes de caractères ne risque-t-elle pas de provoquer des bogues ? 241
L'utilisation de champs de première classe rend-elle les modifications d'API plus difficiles ?
Vous utiliserez trop d'objets et de tableaux 247
Toute grammaire peut être convertie en une fonction de première classe 250
Exemple de boucle : Manger et nettoyer 253
Refactorisation : Remplacement du corps d’une fonction par une fonction de rappel 259
Quelle est cette règle grammaticale ? 262
Pourquoi encapsuler le corps dans une fonction et le passer en paramètre ? 263
Conclusion 265

CHAPITRE 11 Fonctions de première classe II 267

Un problème de code et deux refactorisations 268
Refactorisation Copy-on-Write 269
Refactorisation Copy-on-Write pour les tableaux 270
Fonctions qui renvoient des fonctions 279
Conclusion 288

CHAPITRE 12 Itération fonctionnelle 289

Un problème de code et deux refactorisations 290
MegaMart a décidé de créer une équipe de communication. 291
Dérivation de la fonction map() à travers des exemples 294
Outils fonctionnels : map() 295
Trois façons de passer des fonctions 297
Exemple : Toutes les adresses e-mail des clients 298
Dérivation de la fonction filter() à travers des exemples 301
Outils fonctionnels : filter() 302
Exemple : Le client 303 n’a rien acheté.
Dérivation de reduce() avec exemples 306
Outils fonctionnels : reduce() 307
Exemple : Concaténation de chaînes 308
313 choses que vous pouvez faire avec reduce()
Comparaison de trois outils fonctionnels 315
Conclusion 316

CHAPITRE 13 : Enchaînement fonctionnel des outils 317

L'équipe de communication client travaille toujours 318
Clarifier la chaîne 1 : Nommer les étapes 324
Rendre les chaînes plus claires 2 : Nommer les rappels 325
Clarification de la chaîne 3 : Comparaison des deux méthodes 326
Exemple : Liste d'adresses électroniques de clients n'ayant effectué qu'un seul achat (327)
Refactorisation des boucles avec des outils fonctionnels 332
Conseil 1 : Création de données 333
Astuce 2 : Manipuler un tableau entier en une seule fois 334
Conseil 3 : Décomposez-le en étapes plus petites 335
Comparaison des codes de procédure et de fonction 337
Résumé des conseils d'enchaînement 338
Conseils pour le débogage en chaîne 340
Outils fonctionnels divers 341
reduce() pour créer des valeurs 345
Faites preuve de créativité avec les données 347
Tri par opérateur de méthode 353
Conclusion 354

CHAPITRE 14 Utilisation des outils fonctionnels avec des données imbriquées 355

Fonctions d'ordre supérieur pour la manipulation d'objets 356
Rendre les noms de champs explicites 357
Dérivation de update() 358
Utilisation de la fonction update() pour modifier les valeurs 359
Refactorisation : Remplacer Get, Change et Set par update() 361
Outils fonctionnels : update() 362
Visualisation des valeurs dans les objets 363
Visualisation des mises à jour imbriquées 368
Utilisation de update() avec des données imbriquées 369
Dérivation de updateOption() 370
Dérivation de update2() 371
Visualisation de update2() pour les objets imbriqués 372
Quatre façons de créer incrementSizeByName() 374
Dérivation de update3() 375
Dérivation de nestedUpdate() 377
Utilisation sécurisée de la récursivité 382
Visualisation de nestedUpdate() 383
Pourquoi les fonctions récursives sont appropriées 384
386 éléments à prendre en compte lors de la conception de structures profondément imbriquées
Utilisation des murs d'abstraction pour les données profondément imbriquées 387
Fonctions d'ordre supérieur apprises précédemment 388
Conclusion 389

CHAPITRE 15 : Isoler la chronologie 391

Il y a un bug ! 392
Double-cliquons rapidement sur 393
Un diagramme chronologique illustre ce qui se passe au fil du temps 395
Règles de base du diagramme chronologique à deux lignes 396
Deux détails concernant la séquence d'action que vous pourriez manquer si vous regardez attentivement 400
Élaboration d'une chronologie d'ajout au panier : Étapes 1 à 401
Les appels asynchrones mènent à une nouvelle chronologie 402
Langues différentes, modèles de threads différents 403
Création d'une chronologie étape par étape 404
Élaboration d'une chronologie d'ajout au panier : Étape 2 406
Le diagramme chronologique montre que deux types de code sont exécutés séquentiellement. 407
Un diagramme chronologique montre que l'exécution simultanée de code a un ordre imprévisible 408
Principe 409 d'une bonne chronologie
JavaScript monothread 410
Files d'attente asynchrones en JavaScript 411
AJAX et files d'attente d'événements 412
Exemple asynchrone complet 413
Simplifier la chronologie 414
Lecture de la chronologie complétée 420
Simplifier le processus d'ajout au panier : Étape 3 422
Révision : Élaboration d'une chronologie (Étapes 1 à 3) 424
Résumé : Élaboration d'un diagramme chronologique 426
Si vous comparez les chronologies, vous pouvez constater le problème 427
Double-cliquez lentement et il n'y a aucun problème 428
Un double clic rapide donne des résultats incorrects 429
Les échéanciers qui partagent des ressources peuvent poser problème 430
Conversion des variables globales en variables locales 431
Conversion des variables globales en arguments 432
Rendre le code plus réutilisable 435
Principe : Les fonctions de rappel peuvent être utilisées à la place des valeurs de retour pour une sortie explicite dans les appels asynchrones 436
Conclusion 440

CHAPITRE 16 Partage des ressources entre les chronologies 441

Principes d'une bonne chronologie 442
Il y a toujours un bug dans le panier 443
Nous devons nous assurer de l'ordre dans lequel le DOM est mis à jour 445
Création d'une file d'attente en JavaScript 447
Principe : Inspirer la réalité dans Comment partager 455
Rendre les files d'attente réutilisables 456
Analyse de la chronologie créée jusqu'à présent 461
Règle : Si vous pensez qu'il y a un problème, consultez le diagramme chronologique. 464
Faites passer la file d'attente au 465.
Conclusion 469

CHAPITRE 17 : Ajustez votre chronologie 471

Principes d'une bonne chronologie 472
Il y a un bug ! 473
Comment le code a-t-il changé ? 475
Vérifier l'action : Étape 1 476
Dessiner toutes les actions : Étape 2 477
Simplification du diagramme : Étape 3 481
Analyse de la séquence exécutable 483
Pourquoi le délai est-il plus court maintenant ? 484
Attendez tous les rappels parallèles 486
Primitives de concurrence pour la division des chronologies 487
Application de Cut() au code 489
Analyse des ordres incertains 491
Analyse de l'exécution parallèle 492
Analyse 493 lors de plusieurs clics
Basic 500, appelé une seule fois
Modèles temporels implicites et explicites 502
Résumé : Utilisation de la chronologie 507
Conclusion 508

CHAPITRE 18 Architecture réactive et architecture en oignon 509

Les deux modèles architecturaux sont indépendants 510
Lien de cause à effet étroit pour le changement 511
Qu'est-ce que l'architecture réactive ? 512
Compromis en architecture réactive 513
Cellule en parfait état 514
Vous pouvez rendre ValueCell adaptatif 515
Vous pouvez mettre à jour l'icône d'expédition lorsque la cellule change 516
FormulaCell calcule les valeurs dérivées 517
Programmation fonctionnelle et état mutable 518
Comment l'architecture réactive a transformé les systèmes 519
Distinguer la combinaison de cause et d'effet 520
La séparation de l'union régit le centre de cause et d'effet 521
Traiter plusieurs étapes dans un pipeline 522
Le calendrier devient plus flexible 523
Un autre motif architectural 526
Qu'est-ce que l'architecture en oignon ? 527
Revoir : Actions et calculs, Données 528
Revoir : Conception hiérarchique 529
Architecture hiérarchique traditionnelle 530
Architecture fonctionnelle 531
Il devrait être facile de modifier et de réutiliser 532
Les règles de domaine utilisent les termes de domaine 535
La lisibilité doit être prise en compte 536
Conclusion 539

CHAPITRE 19 : Avant votre parcours en programmation fonctionnelle 541

Plan du chapitre final 542
J'ai appris les compétences d'un expert 543
544 choses à retenir
Évolution des compétences et des passions au fil du temps 545
Devenir un maître avec deux pistes 546
Bac à sable : Démarrer un projet parallèle 547
Bac à sable : Entraînement avec des exercices pratiques 548
Produit : Débarrassez-vous des insectes dès aujourd'hui ! 549
Produit : Améliorez votre design étape par étape 549
550 langages de programmation fonctionnelle populaires
Le langage fonctionnel qui compte le plus d'emplois (552)
552 langages fonctionnels disponibles sur différentes plateformes
553 langages fonctionnels, classés selon ce que vous pouvez apprendre
Acquisition de connaissances mathématiques 554
Lecture complémentaire 555
Conclusion 556

Recherche 557

Comment les développeurs fonctionnels pensent-ils et écrivent-ils du code ?

La programmation fonctionnelle est une nouvelle façon de programmer, différente de la programmation procédurale et de la programmation orientée objet.
Apprendre la programmation fonctionnelle, c'est donc apprendre une nouvelle façon de penser.
Alors, comment les développeurs fonctionnels conçoivent-ils et créent-ils des logiciels ?
Ce livre commence par aborder les effets secondaires, l'aspect le plus fondamental de la programmation fonctionnelle.
Nous apprendrons d'abord à distinguer les actions (fonctions avec effets de bord) des calculs (calculs sans effets de bord). Une fois cette distinction établie, nous verrons comment réduire les actions avec effets de bord et quelles techniques permettent de les transformer en calculs.
Ensuite, nous apprendrons le concept des fonctions de première classe et expliquerons comment réduire les boucles à l'aide de fonctions d'ordre supérieur.
Apprendre cela vous permettra de réutiliser des unités de code fonctionnelles et de faciliter les tests.
Ce processus est expliqué étape par étape afin que vous puissiez facilement comprendre et appliquer ce que vous avez appris en théorie.

Le code d'exemple utilisé dans ce livre est écrit en JavaScript.
JavaScript n'est pas un langage fonctionnel parfait, mais il lui manque certaines caractéristiques des langages fonctionnels, ce qui en fait un bon langage pour illustrer la pensée fonctionnelle.
Elle explique plus en profondeur les concepts fonctionnels en créant soi-même des fonctions fonctionnelles insuffisantes.
Ce livre raconte l'histoire en créant des cas réalistes.
Il est conçu pour être ludique et stimulant, comme si vous faisiez partie de l'équipe de développement de l'entreprise.
En rejoignant l'équipe de développement, vous pourrez observer directement comment les développeurs fonctionnels conçoivent la création de logiciels.
Même si vous n'utilisez pas de langage fonctionnel ou que la programmation fonctionnelle ne vous intéresse pas, apprendre la pensée fonctionnelle vous aidera à développer vos compétences en résolution de problèmes grâce à une nouvelle façon de penser.
Je recommande ce livre aux lecteurs qui souhaitent apprendre la programmation fonctionnelle, ainsi qu'à tous les développeurs qui veulent rendre leur programmation un peu plus concise et claire.

Public cible

■ Professionnels ayant 2 à 5 ans d'expérience en développement logiciel
■ Les développeurs qui créent des systèmes simples mais qui ont des difficultés à gérer des systèmes complexes