Haskell, चेनिंग फिल्टर

Question

लिखने के लिए "नक्शा च (मानचित्र जी XS)" एक कॉल मैप करने के लिए के रूप में आप

उदाहरण XS लिख सकता है = नक्शा (FG) xs

लेकिन कैसे होगा आप फ़िल्टर करने के लिए एक कॉल के रूप में "फ़िल्टर पी (फ़िल्टर क्यू एक्सएस)" लिखते हैं? डॉट ऑपरेटर फ़िल्टर के लिए काम नहीं करता है क्योंकि यह नक्शे के लिए करता है। अनुमान है कि आप भविष्यवाणी के लिए कुछ और उपयोग करेंगे?

Answer 1

आप एक समारोह both है कि इस तरह देखा परिभाषित हैं:

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

तो फिर तुम लिख सकते हैं:

example xs = filter (both p q) xs 

मुझे यकीन है कि एक मानक समारोह है कि आप के लिए यह करता है अगर वहाँ नहीं हूँ। ..

Answer 2

मैं एक सहायक समारोह को परिभाषित करता हूं - शायद यह अधिक घोषणात्मक रूप से लिखा जा सकता है, लेकिन मेरे पास परीक्षण के लिए इस प्रणाली पर जीएचसीआई स्थापित नहीं है:

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

तो

filter (allPredicates [p, q]) xs 

Answer 3

क्यों एक सूची समझ नहीं?

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

Answer 4

कुछ पर कार्यों की एक सूची कॉलिंग अनिवार्य रूप से Control.Monad में ap समारोह क्या करता है। फिर आप परिणाम and परिणाम। केवल मामूली कुरूपता यह है कि ap दोनों के तर्कों को एक ही मोनड (इस मामले में सूची) में होना आवश्यक है, इसलिए हमें यहां काम करने के लिए return के साथ लिखना होगा।

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

Answer 5

मैं लैम्ब्डा अभिव्यक्ति को परिभाषित करता हूं।

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> 

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] 

या अपना स्वयं का ऑपरेटरों यह घोषणा करते हैं कि आप इस बार कर रही हो जाएगा।

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] 

आउटपुट

[5,6,7,8,9] 

सिर्फ इसलिए कि सूचियों तह हैं, और आप विधेय परिणामों को जोड़ सकते हैं All साथ monoid

Answer 8

क्या की तरह कुछ के बारे में:

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

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