Haskell, filtros encadenamiento

Question

para escribir "función f (mapa g XS)" como una sola llamada para mapear podría escribir

XS ejemplo = map (FG) xs

pero ¿cómo lo haría usted escribe "filtro p (filtro q xs)" como una sola llamada para filtrar? el operador punto no parece funcionar para filtro como lo hace para mapas. ¿Supongo que usarías algo más para los predicados?

Answer 1

Si ha definido una función both que se veía así:

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

entonces se podría escribir:

example xs = filter (both p q) xs 

No estoy seguro de si hay una función estándar que lo hace por usted. ..

Answer 2

Definiría una función auxiliar - esto probablemente podría escribirse más declarativamente, pero no tengo instalado GHCI en este sistema para probar:

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

continuación

filter (allPredicates [p, q]) xs 

Answer 3

Por qué no una lista por comprensión?

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

Answer 4

Llamar a una lista de funciones de algo es esencialmente lo que la función ap en Control.Monad hace. Entonces solo and los resultados. La única leve fealdad es que ap requiere que sus dos argumentos estén en la misma mónada (Lista en este caso), por lo que debemos redactarlo con return para que funcione aquí.

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

Answer 5

Definiría una expresión lambda.

module Main where 

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

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

de salida:

$ 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] 

o declarar sus propios operadores, si se va a hacer esto a menudo.

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] 

salidas

[5,6,7,8,9] 

sólo porque las listas son plegables y se pueden combinar los resultados predicado con el All monoid

Answer 8

¿Qué pasa algo como:

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

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