haskell, объединяя фильтры в цепочку

Почему не понимание списка?

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

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

Или объявите свои собственные операторы, если вы будете делать это часто.

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

Я бы определил вспомогательную функцию - ее, вероятно, можно было бы написать более декларативно, но у меня нет установленного GHCI в этой системе для тестирования:

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

затем

filter (allPredicates [p, q]) xs

Вызов списка функций для чего-либо - это, по сути, то, что делает функция ap в Control.Monad. Затем вы просто и результаты. Единственное небольшое уродство заключается в том, что ap требует, чтобы оба его аргумента находились в одной монаде (в данном случае List), поэтому нам нужно скомпоновать его с помощью return , чтобы работать здесь.

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

Я бы определил лямбда-выражение.

module Main where

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

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

вывод:

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

import Data.Foldable
import Data.Monoid

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

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

outputs

[5,6,7,8,9]

just because lists are foldable, and you can combine predicate results with the All monoid