Haskell, filtri concatenamento

Question

di scrivere "funzione f (mappa g xs)" come una singola chiamata per mappare si potrebbe scrivere

esempio xs = map (fg) xs

ma come sarebbe scrivi "filtro p (filtro q xs)" come una singola chiamata da filtrare? l'operatore punto non sembra funzionare come filtro per le mappe. supponendo che useresti qualcos'altro per i predicati?

Answer 1

Se è stato definito una funzione both che si presentava così:

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

allora si potrebbe scrivere:

example xs = filter (both p q) xs 

non sono sicuro se c'è una funzione standard che fa per voi. ..

Answer 2

Definirei una funzione di supporto - probabilmente potrebbe essere scritta in modo più dichiarativo, ma non ho GHCI installato su questo sistema per il test:

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

poi

filter (allPredicates [p, q]) xs 

Answer 3

Perché non una lista di comprensione?

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

Answer 4

Chiamata di un elenco di funzioni in qualcosa è essenzialmente ciò che la funzione ap in Control.Monad fa. Quindi hai appena and i risultati. L'unica leggera bruttezza è che ap richiede che entrambi i suoi argomenti siano nella stessa monade (Elenco in questo caso), quindi è necessario comporlo con return per funzionare qui.

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

Answer 5

Definirei un'espressione lambda.

module Main where 

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

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

uscita:

$ 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 dichiarare i propri operatori, se vi ritroverete a fare questo spesso.

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] 

uscite

[5,6,7,8,9] 

solo perché le liste sono pieghevoli, ed è possibile combinare i risultati predicato con la All monoide

Answer 8

Che dire qualcosa come:

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

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