Programmation fonctionnelle et programmation non fonctionnelle

Au cours de ma deuxième année à l’université, nous avons “appris” Haskell, je n’en sais presque rien et encore moins sur la functional programming.

Qu’est-ce que la functional programming, pourquoi et / ou où pourrais-je l’utiliser au lieu de la programmation non fonctionnelle et est-ce que j’ai raison de penser que C est un langage de programmation non fonctionnel?

Une caractéristique clé dans un langage fonctionnel est le concept de fonctions de première classe. L’idée est que vous pouvez transmettre des fonctions en tant que parameters à d’autres fonctions et les renvoyer en tant que valeurs.

La functional programming implique l’écriture d’un code qui ne change pas d’état. La principale raison à cela est que les appels successifs à une fonction donneront le même résultat. Vous pouvez écrire du code fonctionnel dans n’importe quel langage prenant en charge les fonctions de première classe, mais certains langages, tels que Haskell, ne vous permettent pas de changer d’état. En fait, vous n’êtes pas censé faire d’effets secondaires (comme imprimer du texte), ce qui peut sembler complètement inutile.

Haskell utilise plutôt une approche différente des entrées-sorties: les monades. Ce sont des objects contenant l’opération IO souhaitée à exécuter par le niveau supérieur de votre interpréteur. À tout autre niveau, ce sont simplement des objects dans le système.

Quels sont les avantages de la functional programming? La functional programming permet de coder avec moins de potentiel pour les bogues, car chaque composant est complètement isolé. En outre, l’utilisation de fonctions de récursivité et de première classe permet d’obtenir des preuves simples de correction, qui reflètent généralement la structure du code.

Qu’est-ce que la functional programming?

Il existe deux définitions différentes de “functional programming” couramment utilisées aujourd’hui:

L’ancienne définition (originaire de Lisp) est que la functional programming concerne la programmation en utilisant des fonctions de première classe, c.-à-d. Que les fonctions sont traitées comme des arguments pour d’autres fonctions et que la fonction peut renvoyer des fonctions. Cela aboutit à l’utilisation de fonctions d’ordre supérieur telles que la map et la reduce (vous avez peut-être entendu parler de mapReduce tant mapReduce unique largement utilisée par Google et, sans surprise, c’est un parent proche!). Les types .NET System.Func et System.Action rendent les fonctions d’ordre supérieur disponibles dans C #. Bien que le curry soit peu pratique en C #, les fonctions qui acceptent d’autres fonctions comme arguments sont communes, par exemple la fonction Parallel.For .

La définition plus jeune (popularisée par Haskell) est que la functional programming consiste également à minimiser et à contrôler les effets secondaires, y compris la mutation, c’est-à-dire à écrire des programmes qui résolvent des problèmes en composant des expressions. C’est plus communément appelé “programmation purement fonctionnelle”. Cela est rendu possible par des approches très différentes des structures de données appelées “structures de données purement fonctionnelles”. Un problème est que la traduction des algorithmes impératifs traditionnels pour utiliser des structures de données purement fonctionnelles rend généralement les performances 10 fois plus mauvaises. Haskell est le seul langage de programmation purement fonctionnel, mais les concepts se sont infiltrés dans la programmation grand public avec des bibliothèques comme Linq sur .NET.

où voudrais-je l’utiliser au lieu de la programmation non fonctionnelle

Partout. Les Lambdas en C # ont maintenant démontré des avantages majeurs. C ++ 11 a lambdas. Il n’y a aucune excuse pour ne pas utiliser les fonctions d’ordre supérieur maintenant. Si vous pouvez utiliser un langage comme F #, vous pourrez également tirer parti de l’inférence de type, de la généralisation automatique, du currying et de l’application partielle (ainsi que de nombreuses autres fonctionnalités du langage!).

Ai-je raison de penser que C est un langage de programmation non fonctionnel?

Oui. C est un langage procédural. Cependant, vous pouvez tirer parti des avantages de la functional programming en utilisant des pointeurs de fonction et void * dans C.

Peut-être vaut-il la peine de consulter cet article sur F # “101” sur CoDe Mag récemment publié.

De plus, Dustin Campbell a un super blog où il a publié de nombreux articles sur ses aventures pour se familiariser avec F # ..

J’espère que vous trouvez ces utiles 🙂

MODIFIER:

En outre, pour ma part, ma compréhension de la functional programming est que tout est une fonction, ou des parameters pour une fonction, plutôt que des objects / objects avec état. Mais je peux me tromper. F # est quelque chose que je meurs d’envie de avoir le temps! 🙂

L’exemple de code de John the Statistician ne montre pas la functional programming, car lorsque vous faites de la functional programming, la clé est que le code ne fait AUCUNE AFFECTATION ( record = thingConstructor(t) est une affectation) et qu’il localMap.put(record) PAS D’EFFETS SECONDAIRES ( localMap.put(record) est une déclaration avec un effet secondaire). En raison de ces deux contraintes, tout ce que fait une fonction est entièrement capturé par ses arguments et sa valeur de retour. Réécrire le code du statisticien comme il le faudrait, si vous voulez émuler un langage fonctionnel en utilisant C ++:

 RT getOrCreate (chose de const T, 
                   const Fonction > thingConstructor, 
                   const Map > localMap) {
     retourne localMap.contains (t)?
         localMap.get (t):
         localMap.put (t, thingConstructor (t));
 }

En raison de la règle de non-effets secondaires, chaque instruction fait partie de la valeur de retour (par conséquent le return vient en premier ), et chaque instruction est une expression. Dans les langages qui imposent la functional programming, le mot-clé return est implicite et l’instruction if se comporte comme l’opérateur ?: .

Aussi, tout est immuable, donc localMap.put doit créer une nouvelle copie de localMap et la renvoyer, au lieu de modifier la localMap d’ origine, comme le ferait un programme C ++ ou Java normal. Selon la structure de LocalMap, la copie pourrait réutiliser les pointeurs dans l’original, réduisant ainsi la quantité de données à copier.

Certains des avantages de la functional programming incluent le fait que les programmes fonctionnels sont plus courts et qu’il est plus facile de modifier un programme fonctionnel (car il n’ya pas d’effets globaux cachés à prendre en compte), et il est plus facile première place.

Cependant, les programmes fonctionnels ont tendance à fonctionner lentement (en raison de toutes les copies à effectuer), et ils n’interagissent pas bien avec les autres programmes, processus du système d’exploitation ou systèmes d’exploitation, qui traitent les adresses mémoire, peu nombreuses. blocs d’octets et autres bits non fonctionnels spécifiques à la machine. Le degré de non-interopérabilité tend à être inversement corrélé au degré de pureté fonctionnelle et à la rigueur du système de types.

Les langages fonctionnels les plus populaires ont des systèmes de type vraiment très ssortingcts. Dans OCAML, vous ne pouvez même pas mélanger les mathématiques entières et à virgule flottante, ni utiliser les mêmes opérateurs (+ pour append des entiers, +. Est pour append des flottants). Cela peut être un avantage ou un inconvénient, en fonction de la valeur que vous accordez à un vérificateur de type pour détecter certains types de bogues.

Les langages fonctionnels ont également tendance à avoir de très grands environnements d’exécution. Haskell est une exception (les exécutables GHC sont presque aussi petits que les programmes C, à la fois à la compilation et à l’exécution), mais les programmes SML, Common Lisp et Scheme exigent toujours des tonnes de mémoire.

Oui, vous avez raison de penser que C est un langage non fonctionnel. C est un langage procédural.

Je préfère utiliser la functional programming pour me sauver du travail répété, en faisant une version plus abstraite puis en l’utilisant à la place. Laissez-moi vous donner un exemple. En Java, je me retrouve souvent à créer des cartes pour enregistrer des structures, et donc à écrire des structures getOrCreate.

 SomeKindOfRecord getOrCreate(T thing) { if(localMap.contains(t)) { return localMap.get(t); } SomeKindOfRecord record = new SomeKindOfRecord(t); localMap = localMap.put(t,record); return record; } 

Cela arrive très souvent. Maintenant, dans un langage fonctionnel, je pourrais écrire

 RT getOrCreate(T thing, Function> thingConstructor, Map> localMap) { if(localMap.contains(t)) { return localMap.get(t); } RT record = thingConstructor(t); localMap = localMap.put(t,record); return record; } 

et je n’aurais jamais à en écrire un nouveau, je pourrais en hériter. Mais je pourrais faire mieux alors hériter, je pourrais dire dans le constructeur de cette chose

 getOrCreate = myLib.getOrCreate(*, SomeKindOfRecord.constructor(), localMap); 

(où * est une sorte de notation “laisser ce paramètre ouvert”, qui est une sorte de curry)

et alors le getOrCreate local est exactement le même que si cela avait été écrit, en une seule ligne, sans dépendances d’inheritance.

Si vous cherchez un bon texte sur F #

Expert F # est co-écrit par Don Syme. Créateur de F #. Il a travaillé sur les génériques dans .NET spécifiquement pour pouvoir créer F #.

F # est modélisé après OCaml, donc tout texte OCaml pourrait vous aider à apprendre aussi bien que F #.

Je trouve ce qu’est la functional programming? Être utile

La functional programming consiste à écrire des fonctions pures, à supprimer autant que possible des entrées et des sorties cachées, afin que le plus de code possible décrive simplement une relation entre les entrées et les sorties.

Préférer explicite when param

 public Program getProgramAt(TVGuide guide, int channel, Date when) { Schedule schedule = guide.getSchedule(channel); Program program = schedule.programAt(when); return program; } 

plus de

 public Program getCurrentProgram(TVGuide guide, int channel) { Schedule schedule = guide.getSchedule(channel); Program current = schedule.programAt(new Date()); return current; } 

Un langage fonctionnel est activement hostile aux effets secondaires. Les effets secondaires sont la complexité et la complexité des bugs et des bugs. Un langage fonctionnel vous aidera à être hostile aux effets secondaires.

En informatique, la functional programming est un paradigme de programmation – un style de construction de la structure et des éléments des programmes informatiques – qui traite le calcul comme une évaluation des fonctions mathématiques et évite les données à l’état bloqué et mutables . C’est un paradigme de programmation déclaratif, ce qui signifie que la programmation se fait avec des expressions. Dans le code fonctionnel, la valeur de sortie d’une fonction ne dépend que des arguments entrés dans la fonction. Par conséquent, appeler une fonction f deux fois avec la même valeur pour un argument x produira le même résultat f (x) à chaque fois . L’élimination des effets secondaires, c’est-à-dire des changements d’état qui ne dépendent pas des entrées de la fonction, peut faciliter la compréhension et la prédiction du comportement d’un programme, ce qui constitue l’une des principales motivations du développement de la functional programming. voir pour plus de détails dans le wiki . certains exemples de programmation de langues fonctionnelles sont comme scala, javascript … etc