web-dev-qa-db-fra.com

Lisibilité de programmation fonctionnelle

Je suis curieux de cela parce que je me souviens avant d'apprendre toutes les langues fonctionnelles, je les croyais tout à fait terriblement illisible. Maintenant que je connais Haskell et F #, je trouve que cela prend un peu plus de temps à lire moins de code, mais que ce petit code fait beaucoup plus qu'un montant équivalent dans une langue impérative, il se sent donc un gain net et je ne suis pas extrêmement pratiqué dans fonctionnel.

Voici ma question, j'entends constamment de OOP Les gens que le style fonctionnel est terriblement illisible. Je suis curieux si c'est le cas et que je me fais me trompez, ou si elles prennent le temps d'apprendre Une langue fonctionnelle, tout le style ne serait plus plus illisible que le POOP?

Quelqu'un a-t-il vu des preuves ou obtenu des anecdotes où ils ont vu cela aller d'une manière ou d'une autre avec une fréquence suffisante pour dire? Si l'écriture est vraiment une lisibilité inférieure, je ne veux pas continuer à l'utiliser, mais je ne sais vraiment pas si c'est le cas ou non ..

object-orientedfunctional-programmingreadability
13
Jimmy Hoffa

Réponse courte :

L'un des éléments qui font que les gens disent que le code de programmation fonctionnel est difficile à lire est qu'il donne la préférence à une syntaxe plus compacte.

longue réponse :

La programmation fonctionnelle elle-même ne peut être lisible ou illisible, car c'est un paradigme, pas un style de code d'écriture. En C # Par exemple, la programmation fonctionnelle ressemble à:

return this.Data.Products
    .Where(c => c.IsEnabled)
    .GroupBy(c => c.Category)
    .Select(c => new PricesPerCategory(category: c.Key, minimum: c.Min(d => d.Price), maximum: c.Max(d => d.Price)));

et serait considéré comme lisible par une personne ayant suffisamment d'expérience dans Java, C # ou des langues similaires.

La syntaxe de langue, d'autre part, est plus compacte pour de nombreuses langues fonctionnelles (y compris HASKELLL et F #) par rapport au populaire OOP Langues, donnant une préférence aux symboles plutôt que sur le mot en anglais clair.

Ceci s'applique aux langues extérieures FP aussi. Si vous comparez Popular OOP Langues à des plus populaires qui ont tendance à utiliser plus de mots anglais, les derniers sentiraient plus facile à comprendre pour les personnes sans expérience de programmation.

Comparer:

public void IsWithinRanges<T>(T number, param Range<T>[] ranges) where T : INumeric
{
    foreach (var range in ranges)
    {
        if (number >= range.Left && number <= range.Right)
        {
            return true;
        }
    }

    return false;
}

à:

public function void IsWithinRanges
    with parameters T number, param array of (Range of T) ranges
    using generic type T
    given that T implements INumeric
{
    for each (var range in ranges)
    {
        if (number is from range.Left to range.Right)
        {
            return true;
        }
    }

    return false;
}

De la même manière:

var a = ((b - c) in 1..n) ? d : 0;

pourrait être exprimé dans une langue imaginaire comme suit:

define variable a being equal to d if (b minus c) is between 1 and n or 0 otherwise;

Quand la syntaxe plus courte est meilleure?

Bien que plus de syntaxe verbeuse soit plus facile à comprendre pour un débutant, une syntaxe plus compacte est plus facile pour les développeurs expérimentés. Le code plus court signifie moins de caractères à taper, ce qui signifie plus de productivité.

Surtout, il n'a pas vraiment de sens à forcer une personne à taper un mot clé pour indiquer quelque chose qui peut être déduit de la syntaxe.

Exemples:

  • In PHP Vous devez taper function avant chaque fonction ou chaque méthode, sans raison spécifique de le faire.

  • ADA m'a toujours horrifié pour avoir forcé les développeurs à taper beaucoup de mots anglais, d'autant plus qu'il n'y a pas de correction IDE avec l'achèvement automatique. Je n'ai pas utilisé ADA récemment et que leur tutoriel officiel est en panne. Je ne peux pas donner un exemple; si quelqu'un a un exemple, n'hésitez pas à modifier ma réponse.

  • La syntaxe 1..n, Utilisée dans de nombreux FP (et MATLAB) peut être remplacée par between 1, n Ou between 1 and n Ou between (1, n). Le mot clé between permet de comprendre beaucoup plus facilement pour les personnes qui ne connaissent pas la syntaxe de langue, mais toujours, deux points sont beaucoup plus rapides à taper.

12
Arseni Mourzenko

Je pense que l'une des raisons est que la programmation fonctionnelle a tendance à travailler avec des concepts beaucoup plus abstraits. Cela rend le code plus court et plus lisible pour les personnes qui connaissent et comprennent les concepts (car ils expriment justement l'essence du problème), mais il est illisible pour les personnes qui ne sont pas familières avec eux.

Par exemple, pour un programmeur fonctionnel, il est naturel d'écrire un code pouvant échouer à différents points de la monade Maybe monad, ou Either monad. Ou, pour écrire un calcul d'état avec l'aide du State monad. Mais pour quelqu'un qui ne comprend pas le concept de monades, tout cela ressemble à une sorte de sorcellerie noire.

Je pense donc que cela serait raisonnable d'utiliser des bits de programmation fonctionnelle même dans une équipe de OOP personnes, tant que l'on utilise des concepts faciles à comprendre ou à apprendre, comme la cartographie sur une collection avec une fonction ou fermetures .

(Et bien sûr, cela dépend également du programmeur qui a écrit un code de code. Vous pouvez écrire un code horriblement illisible dans n'importe quelle langue, ainsi que vous pouvez écrire dans un style agréable et propre.)

6
Petr Pudlák

La lisibilité du code est subjective. Je suis sûr que certaines personnes le critiquent par manque de compréhension. Il existe des idiomes naturellement différents de la manière dont les modèles courants sont mis en œuvre. Par exemple, le modèle de visiteur n'a pas vraiment de sens dans une langue avec une correspondance de motif .

L'inférence de type peut être une fonctionnalité délicate. Habituellement, c'est un grand accélérateur de développement, cependant, il peut parfois être difficile de comprendre quels types sont impliqués en raison du manque de contexte menant à des erreurs déroutantes. Cela ne se limite pas à quelles langages de programmation fonctionnelle - je l'ai vue dans des modèles C++!

Les langues modernes ont tendance à être multi-paradigme . Cela inclut à la fois C # et F #. Il est possible d'écrire un style fonctionnel en C # et un style impératif en F #. Les mêmes personnes qui critiquent les langues fonctionnelles écrivent probablement du code fonctionnel dans leur langue orientée objet.

Le développement commercial en langues fonctionnelles est encore relativement immature. J'ai vu un certain nombre d'erreurs qui seraient considérées comme une mauvaise forme dans n'importe quelle langue. Tel que:

  1. Changer de style lorsque vous apprenez la langue (et non refactoring) menant à une incohérence.
  2. Trop dans un seul fichier.
  3. Trop de déclarations sur une ligne.
1
Dave Hillier