Appel d'un scénario de test en Haskell et instructions else if

Question

Ok, j'ai regardé plusieurs questions similaires, mais je suis toujours un peu perdu.

J'ai donc mis en place plusieurs scénarios de test en utilisant des assertions, et j'essaie d'écrire un programme qui utilise l'entrée du scénario de test et les sorties en utilisant des instructions if-else et la récursion. Je continue à obtenir une erreur d'analyse sur mes instructions if.

pas le code réel, juste un exemple de ce que j'essaie de faire

Ma question est la suivante : comment puis-je configurer un programme pour appeler les "tests" correctement ?

J'ai donc un nombre entier "n" donné par mon premier cas de test tl1, Je veux vérifier si n est pair, s'il l'est alors le multiplier par 2, s'il est impair alors le multiplier par 3 et attribuer la nouvelle valeur à n.

Voici donc la partie que j'essaie d'écrire afin d'accepter l'entrée d'un cas de test similaire au code du cas de test donné.

tests :: if (mod n 2) = 0
         then tests (n * 2)
         else tests (n * 3)   

tests = 
        testlist [
                   tl1
                  ,tl2
                  ,tl3
                 ]

Answer 1

Je n'ai pas bien compris laquelle des trois fonctions suivantes vous vouliez, alors je les ai toutes exécutées :

testListAll :: [a -> Bool] -> a -> Bool
testListAll xs a = and $ map ($ a) xs

testListAny :: [a -> Bool] -> a -> Bool
testListAny xs a = or $ map ($ a) xs

testListList  :: [a -> Bool] -> a -> [Bool]
testListList xs a = map ($ a) xs

Donc, par exemple,

> testListAll [(> 5), (== 7), even] 4
False
> testListAny [(> 5), (== 7), even] 4
True
> testListAll [(> 5), (== 8), even] 8
True
> testListList [(> 5), (== 8), even] 10
[True,False,True]

Maintenant, nous pouvons écrire des fonctions comme

test :: Integral a => a -> Bool
test n = if even n 
        then testListAll [(> 5), (< 9)] n
        else testListAny [(<= 5), (> 8)] n

donner

> test 5
True
> test 6
True
> test 7
False
> test 8
True
> test 9
True
> test 10
False
> test 11
True

---

Explication

Je vais expliquer une fonction en détail ; les autres fonctionnent de manière très similaire.

La première fonction pourrait être écrite peut-être plus simplement comme :

testListAll' :: [a -> Bool] -> a -> Bool
testListAll' xs a = and [f a | f <- xs]

donc ce qu'il fait c'est prendre chaque fonction de test f de la liste et l'appliquer à la valeur de test a . La fonction and :: [Bool] -> Bool donne Vrai si tout dans la liste est Vrai ; cette fonction vérifie si tous les contrôles sont satisfaits.

Alors pourquoi ai-je écrit le côté droit comme and $ map ($ a) xs ? Eh bien, en [f a | f <- xs] Je fais la même chose pour tous les éléments f de xs J'ai donc immédiatement pensé à faire cela avec map .

Pensez d'abord à

  map (+ 4) [1,2,3,4]
= [(+4) 1,  (+4) 2,  (+4) 3, (+4) 4]
= [1+4, 2+4, 3+4, 4+4]
= [5,6,7,8]

pour voir comment nous utilisons l'opérateur d'application de fonction (de faible précédence) $

  map ($ a) [(>4), (==7), (<10)]
= [($ a) (>4),  ($ a) (==7),  ($ a) (<10)]
= [(>4) $ a,  (==7) $ a,  (<10) $ a]
= [(>4) a,  (==7) a,  (<10) a]
= [a > 4 , a==7, a < 10]

Ce qui vous donne le même résultat que [f a| a <- [(>4), (==7), (<10)]] .