Traduire le flux de contrôle impératif avec Break-S / Continu-s à Haskell

Alors, pensant fonctionnellement, vous devriez rechercher des moyens de ne pas vous poser de problème de ne pas se lancer dans des boucles et des étapes, mais dans des fonctions.

Donc, si nous avions une fonction maxhere f xs code> qui a renvoyé le plus grand x code> pour lequel fx code> est vrai, nous pourrions écrire: p> xxx pré>

une implémentation naïf de maxe est p>

maxWhere f xs = foldl' r 0 xs
    where r a x
       | x > a     = if f x then x else a
       | otherwise = a

Ce type de boucle se prête facilement à une compréhension de la liste, comme ceci: xxx pré>

où nous pourrions écrire ispalindrome comme ceci: p> xxx pré> p> C'est vraiment assez rapide, bien que la sorte de peu demartypantsy, donc d'abord, nous remarquerons que nous vérifions les chiffres deux fois. Disons que a * b est le plus grand palindrome, alors nous vérifierons à la fois le cas où x == a, y == b code> et x == b, y == A code>. Nous arrêtons donc d'abord cela en limitant les chiffres que nous recherchons uniquement aux cas où x> = y, comme ceci: p> xxx pré>

ceci coupe les chiffres à tester en deux. P>

Dans votre solution Python, vous avez également lié à Y ci-dessous par le plus grand numéro que nous avons trouvé jusqu'à présent divisé par le X ( x * y => curmax code>), également que vous ne cherchez jamais au-delà du premier y trouvé (briser la boucle interne si Curmax est mise à jour). Nous pouvons réduire la recherche en ne poursuivant pas si le premier élément que nous vérifions (x carré) est inférieur à notre réponse actuelle, car toutes les vérifications suivantes sont plus petites, mais ceci est au-delà de ce qui semble bien dans une compréhension de la liste afin que nous déplacions notre recherche. C'est sa propre fonction: p>

*Main> search 999 0
906609

Comme indiqué par Stephen Tetley Strong> Dans son commentaire, vous pouvez utiliser le style de passage de continuation pour gérer le flux de contrôle complexe ( cont code> monad plus son callcc Code> qui est en quelque sorte similaire à pause code>. ... ou même goto code> - Abus de CPS peut conduire à un code plutôt incompréhensible - voir mon exemple ci-dessous):

import Control.Monad.Cont
import Control.Monad.State.Strict

solcs = runCont (execStateT comp 0) id
    where   
      comp = forM_ range $ \i -> callCC $ \break ->
                forM_ range $ \j -> do
                  let ij = i*j
                  m <- get
                  when (ij < m) (break ())
                  when (pal ij) (put ij)  

Je pense que vous pouvez faire ce que vous voulez utiliser deux fonctions mutuellement récursives.

Voici un exemple beaucoup plus simple (extrait de un tutoriel sur ATS ): xxx

Le code écrit ci-dessus est très similaire à ce que tu voudrais Ecrire en C (extrait de la même page):

int Main (int Argc, char * argv []) { int i, j; xxx

}

Comme vous le voyez, les boucles imbriquées deviennent des fonctions mutuellement récursives; et des variables mutables I et J Devenir des variables d'induction. LOOP1 correspond à la boucle extérieure, tandis que la boucle2 à la boucle interne.