La programmation de sans si-états?

Tout ce "si" vs "pas si" la chose qui me fait penser à la L'Expression De Problème¹. Fondamentalement, c'est une observation que de la programmation avec les si les déclarations ou sans if est une question d'encapsulation et de l'extensibilité et qu'il est parfois préférable d'utiliser des instructions if² et parfois il vaut mieux utiliser la dynamique de dispatching, avec des méthodes et des pointeurs de fonction.

Quand on veut modéliser quelque chose, il y a deux axes à s'inquiéter:

1. Les différents cas (ou types) de l'intrants dont nous avons besoin pour traiter avec.
2. Les différentes opérations que vous souhaitez effectuer sur ces entrées.

Une façon de mettre en œuvre ce genre de chose est avec des instructions if /filtrage /le modèle visiteur:

data List = Nil | Cons Int List

length xs = case xs of
  Nil -> 0
  Cons a as -> 1 + length x

concat xs ys = case ii of
  Nil -> jj
  Cons a as -> Cons a (concat as ys)

L'autre moyen est d'utiliser l'orientation de l'objet:

data List = {
    length :: Int
    concat :: (List -> List)
}

nil = List {
    length = 0,
    concat = (\ys -> ys)
}

cons x xs = List {
    length = 1 + length xs,
    concat = (\ys -> cons x (concat xs ys))
}

Il n'est pas difficile de voir que la première version à l'aide des instructions if il est facile d'ajouter de nouvelles opérations sur notre type de données: il suffit de créer une nouvelle fonction et de faire une analyse de cas à l'intérieur. D'autre part, il est difficile d'ajouter de nouveaux cas de notre type de données car cela voudrait dire passer par le programme et la modification de tous les les instructions de branchement.

La deuxième version est un peu le contraire. Il est très facile d'ajouter de nouveaux cas au type de données: il suffit de créer une nouvelle "classe" et de dire ce qu'il faut faire pour chacune des méthodes, nous avons besoin de mettre en œuvre. Toutefois, son désormais difficile d'ajouter de nouvelles opérations à l'interface car cela signifie l'ajout d'une nouvelle méthode pour toutes les anciennes classes en œuvre de l'interface.

Il existe de nombreuses approches différentes langues à utiliser pour tenter de résoudre le Problème de l'Expression et de faciliter l'ajout de deux nouveaux cas et de nouvelles opérations pour un modèle. Cependant, il ya des avantages et des inconvénients de ces solutions³ donc, en général, je pense que c'est une bonne règle de base pour choisir entre OO et si les déclarations selon quel axe vous voulez le rendre plus facile à étendre choses.

De toute façon, pour en revenir à votre question il y a le couple o choses que je voudrais souligner:

La première est que je pense que l'OO "mantra" de se débarrasser de tous si les déclarations et les remplacer par la méthode d'envoi a plus à voir avec la façon dont la plupart des langages à objets n'ont pas de typesafe Types de Données Algébriques qu'il a à faire avec des "si statemsnts" étant mauvais pour l'encapsulation. Car la seule manière d'être sûr est d'utiliser les appels de méthode, vous êtes encouragés à les convertir à l'aide de programmes si les déclarations dans les programmes à l'aide de la Modèle Visiteur⁴ ou pire: convertir les programmes qui devraient être en utilisant le modèle visiteur dans les programmes à l'aide de simple méthode de répartition, par conséquent, faire l'extensibilité facile dans la mauvaise direction.

La deuxième chose, c'est que je ne suis pas un grand fan de freinage choses dans des fonctions simplement parce que vous le pouvez. En particulier, je trouve que le style dans lequel toutes les fonctions ont juste 5 lignes et d'appeler des tonnes d'autres fonctions est assez difficile à lire.

Enfin, je pense que votre exemple n'a pas vraiment de se débarrasser de si consolidés. Essentiellement, ce que vous faites est d'avoir une fonction à partir de nombres Entiers à un nouveau type de données (avec deux affaires, l'une pour les Grands et un pour les Petits), puis vous devez les utiliser si les déclarations lors du travail avec le type de données:

data Size = Big | Small

toSize :: Int -> Size
toSize n = if n < 10 then Small else Big

someOp :: Size -> String
someOp Small = "Wow, its small"
someOp Big   = "Wow, its big"

Revenir à l'expression du problème de point de vue, l'avantage de la définition de notre toSize /isSmall fonction est de mettre la logique du choix de ce cas, notre nombre s'inscrit dans un lieu unique et que ses fonctions ne peut fonctionner que sur le cas par la suite. Toutefois, cela ne signifie pas que nous avons supprimé si les déclarations de notre code! Si nous avons la toSize étant une fonction de fabrication et nous avons de Grands et de Petits être des classes partage d'une interface, alors oui, nous aurons enlevé si les déclarations de notre code. Toutefois, si isSmall retourne un booléen ou enum ensuite, il sera tout autant, si les déclarations qu'il y avait avant. (et vous devez choisir la mise en œuvre qu'à utiliser en fonction de si vous voulez faire plus facile d'ajouter de nouvelles méthodes ou de nouveaux cas - dire de Moyenne dans l'avenir)

---

1 - le nom de La problème vient de le problème où vous avez une "expression" de type de données (nombres, des variables, addition/multiplication des sous-expressions, etc) et que vous souhaitez mettre en œuvre des choses comme les fonctions d'évaluation et d'autres choses.

2 Ou pattern matching sur des Types de Données Algébriques, si vous voulez être plus sécurisé...

3 - Par exemple, vous pouvez définir tous les multimethods sur le "haut niveau", où le "répartiteur" peut les voir. C'est une limitation par rapport au cas général, puisque vous pouvez l'utiliser si les états (et les lambdas) profondément imbriquée à l'intérieur d'un autre code.

4 - Essentiellement d'une "église" codage d'un type de données algébrique

OriginalL'auteur hugomg

Je n'ai jamais entendu parler d'une telle convection. Je ne vois pas comment il fonctionne, de toute façon. Sûrement le seul point d'avoir un iIsSmall est pour plus tard branche (éventuellement en combinaison avec d'autres valeurs)?

Ce que je ont entendu parler de est un argument pour éviter d'avoir des variables comme iIsSmall à tous les. iIsSmall est juste de stocker le résultat d'un test que vous faites, de sorte que vous pouvez par la suite utiliser ce résultat pour rendre une décision. Alors pourquoi ne pas tester la valeur de i au point où vous en avez besoin pour prendre la décision? c'est à dire, au lieu de:

int i = 5; 
bool iIsSmall = isSmall(i);
...
<code>
...
if (iIsSmall) {
    <do something because i is small>
} else {
    <do something different because i is not small>
}

il suffit d'écrire:

int i = 5
...
<code>
...
if (isSmall(i)) {
    <do something because i is small>
} else {
    <do something different because i is not small>
}

De cette façon, vous pouvez dire au point de ramification de ce que vous êtes réellement ramification sur parce que c'est là. Ce n'est pas dur dans cet exemple, de toute façon, mais si le test a été compliqué, vous n'allez probablement pas être capable d'encoder le tout dans le nom de la variable.

C'est aussi plus sûr. Il n'y a pas de danger que le nom iIsSmall est trompeuse, car vous avez modifié le code afin d'essais autre chose, ou parce que i a été modifiée après que vous avez appelé isSmall de sorte qu'il n'est pas nécessairement petit plus, ou parce que quelqu'un a juste pris un muet nom de la variable, etc, etc.

Évidemment, cela ne fonctionne pas toujours. Si le isSmall test est coûteux et vous avez besoin de branche sur son résultat de nombreuses fois, vous ne voulez pas exécuter de nombreuses fois. Vous aussi vous pourriez ne pas vouloir dupliquer le code de l'appeler plusieurs fois, sauf si c'est trivial. Ou vous pouvez retourner le drapeau à être utilisé par un visiteur qui ne connaît pas i (même si ensuite, vous pouvez simplement retourner isSmall(i), plutôt que de le stocker dans une variable et ensuite de retour à la variable).

---

Btw, la fonction séparée enregistre rien dans votre exemple. Vous pouvez inclure (i < 10) dans une affectation à un bool variable aussi facilement que dans une instruction de retour dans un bool fonction. ex: vous pouvez tout aussi bien écrire bool isSmall = i < 10; - c'est ce qui évite l'instruction si, pas la fonction séparée. Code de la forme if (test) { x = true; } else { x = false; } ou if (test) { return true; } else { return false; } est toujours stupide; il suffit d'utiliser x = test ou return test.

OriginalL'auteur Ben