haskell, filtres enchaînant

Question

à écrire "carte f (carte g xs)" comme un seul appel à la carte vous pouvez écrire

exemple xs = carte (fg) xs

mais comment vous écrivez "filtre p (filtre q xs)" comme un seul appel à filtrer? l'opérateur point ne semble pas fonctionner pour le filtre comme il le fait pour les cartes. deviner que vous utiliseriez autre chose pour les prédicats?

Answer 1

Si vous avez défini une fonction both qui ressemblait à ceci:

both :: (a -> Bool) -> (a -> Bool) -> a -> Bool 
both f g x = f x && g x 

Ensuite, vous pouvez écrire:

example xs = filter (both p q) xs 

Je ne sais pas s'il y a une fonction standard qui fait cela pour vous.

Answer 2

Je définirais une fonction d'assistance - ceci pourrait probablement être écrit de façon plus déclarative, mais je n'ai pas installé GHCI sur ce système pour le tester:

allPredicates :: [a -> Bool] -> a -> Bool 
allPredicates []  _ = True 
allPredicates (p:ps) x = p x && allPredicates ps x 

puis

filter (allPredicates [p, q]) xs 

Answer 3

Pourquoi pas une compréhension de la liste?

example = [x | x <- xs, p x, q x] 
-- for example 
example = [x | x <- [1..10], (>3) x, x<5 ] -- [4] 

Answer 4

Appeler une liste de fonctions sur quelque chose est essentiellement ce que la fonction ap dans Control.Monad fait. Alors vous juste and les résultats. La seule petite laideur est que ap exige que ses deux arguments soient dans la même monade (Liste dans ce cas), donc nous devons le composer avec return pour travailler ici.

import Control.Monad 
filterByMany funcs = filter (and . ap funcs . return) 

Answer 5

Je définirais une expression lambda.

module Main where 

overTen :: Int -> Bool 
overTen = (>10) 

main :: IO() 
main = do 
    print $ filter (\x -> overTen x && even x) [1..20] 

sortie:

$ ghci Test.hs 
GHCi, version 6.10.4: http://www.haskell.org/ghc/ :? for help 
Loading package ghc-prim ... linking ... done. 
Loading package integer ... linking ... done. 
Loading package base ... linking ... done. 
[1 of 1] Compiling Main    (Test.hs, interpreted) 
Ok, modules loaded: Main. 
*Main> main 
[12,14,16,18,20] 
*Main> 

Answer 6

 
$ ghci 
Prelude> :m +Control.Arrow 
Prelude Control.Arrow> :t uncurry (&&) . ((0 <) &&& (< 10)) 
uncurry (&&) . ((0 <) &&& (< 10)) :: (Num a, Ord a) => a -> Bool 
Prelude Control.Arrow> filter (uncurry (&&) . ((0 <) &&& (< 10))) [0..15] 
[1,2,3,4,5,6,7,8,9] 

Ou Déclarez vos propres opérateurs, si vous allez faire souvent.

infixr 3 &&: 
p &&: q = \a -> p a && q a 
infixr 2 ||: 
p ||: q = \a -> p a || q a 
not' = (.) not 
all' = foldr (&&:) $ const True 
any' = foldr (||:) $ const False 

example xs = filter (p &&: q ||: not' r) xs 

Answer 7

import Data.Foldable 
import Data.Monoid 

p = (>4) 
g = (<10) 

main = print $ filter (getAll . foldMap (All.) [p,g]) [1..10] 

sorties

[5,6,7,8,9] 

juste parce que les listes sont pliables, et vous pouvez combiner les résultats sous-jacentes à la All MONOID

Answer 8

Qu'en est-il quelque chose comme:

example xs = filter (forAll [p,q,r,s,t,u,v]) xs 

forAll:: [(a -> Bool)] -> a -> Bool 
forAll funcs x = all (map ($ x) funcs)