Erlang : Retour d'une fonction

J'ai une fonction dans laquelle j'ai une série de cas individuels consolidés.

case ... of
     ...
end,

case ... of
     ...
end,

...

etc.

Je veux le retour de la fonction immédiatement lorsqu'un cas particulier de la condition se produit dans l'un des cas énoncés de sorte que la prochaine instruction case n'est pas cochée, et la fonction juste sorties/retours. Comment dois-je faire?

OriginalL'auteur jeffreyveon | 2009-12-08

erlang functional-programming

14

Je vous suggère de refactoriser pour exploiter la pleine puissance de Erlang et son pattern matching capacités.

Il n'y a pas un return de l'opérateur. Aussi, un fait peu connu est que vous pouvez faire quelque chose comme:

Return=case ... of

un case déclaration peut avoir un "retour" de la valeur.

C'est pourquoi il est appelé un cas d'expression.
Oui, c'est quelque chose de très bon à savoir! merci.
ma réponse satisfaire votre question?
Oui, merci, merci de m'avoir aidé à y aller avec erlang 🙂

OriginalL'auteur jldupont
12

Pattern matching est une bonne façon de revoir une instruction de cas - vous pouvez faire quelque chose comme ceci
```
testcase(1, X, Y) -> .... passed1;
testcase(2, X, Y) -> .... passed2;
testcase(N, X, Y) when N > 2 -> .... passedlarge;
testcase(_, X, Y) -> defaultcase.
```
et puis votre cas simplement roulés jusqu'à:
```
X = testcase(Number, Param1, Param2).
```
(X sera soit passed1, passed2, passedlarge ou defaultcase dans cet exemple artificiel)

Ok, génial, merci!

OriginalL'auteur Alan Moore
4

Erlang n'ont pas de return de l'opérateur. Vous aurez besoin de revoir votre code en petites fonctions.

Votre code original a deux cas expressions enchaîné avec l'opérateur virgule. Je présume que vous avez des effets secondaires dans le premier cas, l'expression que vous souhaitez conserver. Ci-dessous, je suis en utilisant un imaginaire return opérateur:
```
case ... of
  P1 -> return E1;
  P2 -> E2;
end,

case ... of
  ...
end
```
Une expression de ce genre peut être converti à la vraie Erlang code à l'aide de petites fonctions et le pattern matching avec quelque chose ressemblant à ceci:
```
case1(P1, ...) -> E1;
case1(P2, ...) -> E2, case2(...).
case2(...) -> ...
```
Avertissement: Cela fait 10 ans que j'ai écrit Erlang code, de sorte que ma syntaxe est peut-être éteint.

Veuillez fournir un exemple de le faire.
Exemple ajouté, j'espère que cela aide.

OriginalL'auteur Ville Laurikari
2

En Erlang vous suffit d'utiliser le pattern matching pour déclencher la fonction appropriée. Si vous avez trop de clauses de couvrir et de les traiter avec je vous suggère aussi de revoir un peu le code.

OriginalL'auteur markmywords

Une façon est d'cascade votre cas déclarations:

my_fun(X) ->
  case cond1(X) of
    true -> ret1;
    _ ->
      case cond2(X) of
        true -> ret2;
        _ ->
          ...
      end
  end.

Une autre est de séparer votre cas énoncés dans les clauses:

my_fun(X) ->
  my_fun(cond1, X).

my_fun(cond1, X) ->
  case cond1(X) of
    true -> ret1;
    _    -> my_fun(cond2, X)
  end;

my_fun(cond2, X) ->
  case cond2(X) of
    true -> ret2;
    _    -> my_fun(cond3, X)
  end;

...

OriginalL'auteur Zed

1

utilisation attraper/lancer

L'appelant dit:
```
X = (capture foo(A, B)). 
```
puis écrire
```
foo(A, B) -> 
cas de ... 
...lancer(X) .. 
fin, 

cas de ... 
... lancer (Y) 
fin, 
... 
```
Cela est généralement considéré comme une mauvaise programmation de la pratique depuis que le programme a plusieurs
les points de sortie et il est difficile de grock

Jeter en Erlang est spécifiquement pour les retours, pas de gestion des erreurs - donc, en principe, c'est une approche valable. Dans la pratique, je soupçonne que le refactoring pour éviter qu'il serait mieux ici, mais sans voir le code, il est difficile de savoir.
En principe, il pourrait être une approche valable, et c'est en effet pour les non-local de rendement, mais il est toujours une mauvaise pratique de l'utiliser partout dans votre code. À l'aide de non-local retourne rend très difficile pour les autres programmeurs à comprendre le code, et le rend plus difficile à déboguer. Alors qu'il n'est pas conçu spécifiquement pour la gestion des erreurs la gestion des erreurs est généralement le seul endroit où vous devriez l'utiliser. En outre, si vous êtes codant pour la gestion d'erreur, vous n'êtes pas à la suite d'un noyau Erlang philosophie, qui est le "code de la réussite" : vous êtes en train de penser plus comme un impératif programmeur.

OriginalL'auteur ja.

Vous devez vous connecter pour publier un commentaire.