Erreur Haskell: Impossible de faire correspondre le type attendu `Bool 'au type inféré` IO b'

Question

Je ne comprends pas quel est le problème. 'a' n'est pas un booléen et ne devrait pas être un booléen. Alors, pourquoi Bool est-il attendu?

code:

probablyPrime n 0 = False 
probablyPrime n t = 
     do a <- randomRIO(3, n-1 :: Integer)  
     let comp = defComp(a,n)  
     let ret = (not comp) && (probablyPrime n t-1) 
     return ret 


defComp a n = xcon1 && xcon2 
where (s,m) = findsm n 
     x = a^m `mod` n 
     xcon1 = x /= 1 || x /= n-1 
     xcon2 = comploop x n s 


comploop x n 0 = False 
comploop x n s = x1 || (comploop x n (s-1)) 
    where x1 = (x^2 `mod` n) == 1 


findsm n = (s,m) 
where m = findm n 
     s = n/m 


findm n = m 
    where f = (logBase 2 n) - (truncate (logBase 2 n)) 
     m' = 2^f 
     m = m_ify m' 


m_ify m | m mod 1 == 0 = m 
    | otherwise = m_ify (m*2) 

Erreur:

Couldn't match expected type `Bool' against inferred type `IO b' 
In a stmt of a 'do' expression: 
    a <- randomRIO (3, n - 1 :: Integer) 
In the expression: 
    do { a <- randomRIO (3, n - 1 :: Integer); 
     let comp = defComp ...; 
     let ret = (not comp) && (probablyPrime n t - 1); 
     return ret } 
In the definition of `probablyPrime': 
    probablyPrime n t 
        = do { a <- randomRIO (3, n - 1 :: Integer); 
          let comp = ...; 
          let ret = ...; 
          .... } 

Answer 1

Le type de probablyPrime devrait être IO Bool, de sorte que votre premier match de motif doit soulever la valeur pure de faux dans la monade IO en utilisant la fonction de retour , changer fondamentalement:

probablyPrime n 0 = False 

à

probablyPrime n 0 = return False 

Vous ne pouvez pas esacpe la monade IO sans utiliser de fonctions non sécurisées, mais vous ne devriez pas le faire à moins de savoir exactement ce que vous faites.

Answer 2

probablyPrime n 0 = False 

Cela indique haskell que le type de retour est probablyPrimeBool. Cependant, dans le second cas, vous avez affaire à des monades et vous retournez IO Bool, donc les types ne correspondent pas.

Remplacez False par return False et cela fonctionnera.

Vous devrez aussi changer

let ret = (not comp) && (probablyPrime n t-1) 

à

prob <- probablyPrime n (t-1) 
let ret = (not comp) && prob 

ou quelque chose comme

ret <- liftM ((not comp) &&) (probablyPrime n (t-1)) 

comme Andrew Jaffe a souligné.

Answer 3

Il est une bonne idée d'éviter IO chaque fois que vous le pouvez, et en utilisant le State monade est un moyen pratique de le faire ici:

import Control.Applicative ((<$>)) 
import Control.Monad (liftM, replicateM) 
import Control.Monad.State (State, evalState, get, put) 
import System.Random 

probablyPrime :: RandomGen g => Int -> Int -> State g Bool 
probablyPrime t = liftM and . replicateM t . checkOnce 
    where 
    checkOnce :: RandomGen g => Int -> State g Bool 
    checkOnce n = do 
     (a, gen) <- randomR (3, n - 1) <$> get 
     put gen 
     return . not $ defComp a n 

defComp = undefined 

Pour tester si un nombre est (probablement) prime que vous effectuez les opérations suivantes (note que j'ai changé l'ordre des arguments à probablyPrime, puisque t est moins susceptible de varier de n):

evalState (probablyPrime 10 7057) <$> newStdGen :: IO Bool 

Cela vous permet d'éviter d'entrer dans IO jusqu'à ce que ce soit absolument nécessaire.