Sind diese beiden Kombinatoren bereits in Haskell verfügbar?

Question

Ich brauche binäre combinators des Typs

(a -> Bool) -> (a -> Bool) -> a -> Bool 

oder vielleicht

[a -> Bool] -> a -> Bool 

(obwohl dies wäre nur die foldr1 der ersten, und ich brauche in der Regel nur zwei Booleschen Funktionen zu kombinieren.)

Sind diese eingebaut?

---

Wenn nicht, ist die Implementierung einfach:

both f g x = f x && g x 
either f g x = f x || g x 

oder vielleicht

allF fs x = foldr (\ f b -> b && f x) True fs 
anyF fs x = foldr (\ f b -> b || f x) False fs 

Hoogle taucht nichts, aber manchmal seine Suche nicht richtig verallgemeinern. Irgendeine Idee, wenn diese eingebaut sind? Können sie aus Teilen einer bestehenden Bibliothek gebaut werden?

Wenn diese nicht integriert sind, könnten Sie neue Namen vorschlagen, weil diese Namen ziemlich schlecht sind. In der Tat, das ist der Hauptgrund, ich hoffe, dass sie eingebaut sind.

Answer 1

Control.Monad definiert eine instance Monad ((->) r), so

 
ghci> :m Control.Monad 
ghci> :t liftM2 (&&) 
liftM2 (&&) :: (Monad m) => m Bool -> m Bool -> m Bool 
ghci> liftM2 (&&) (5 <) (< 10) 8 
True 

Sie könnten mit Control.Applicative.liftA2 das gleiche tun.

---

nicht ernst es vorschlagen, aber ...

 
ghci> :t (. flip ($)) . flip all 
(. flip ($)) . flip all :: [a -> Bool] -> a -> Bool 
ghci> :t (. flip ($)) . flip any 
(. flip ($)) . flip any :: [a -> Bool] -> a -> Bool 

Answer 2

Ich kenne Builtins nicht, aber ich mag die Namen, die Sie vorschlagen.

getCoolNumbers = filter $ either even (< 42) 

Alternativ könnte man auch ein Operator-Symbol neben Typklassen für Alternativen vorstellen.

getCoolNumbers = filter $ even <|> (< 42) 

Answer 3

Es ist kein builtin, aber die Alternative I bevorzugen Typklassen zu verallgemeinern die Boolesche Operationen zu Prädikaten von jedem verwenden Arity:

module Pred2 where 

class Predicate a where 
    complement :: a -> a 
    disjoin :: a -> a -> a 
    conjoin :: a -> a -> a 

instance Predicate Bool where 
    complement = not 
    disjoin = (||) 
    conjoin = (&&) 

instance (Predicate b) => Predicate (a -> b) where 
    complement = (complement .) 
    disjoin f g x = f x `disjoin` g x 
    conjoin f g x = f x `conjoin` g x 


-- examples: 

ge :: Ord a => a -> a -> Bool 
ge = complement (<) 

pos = (>0) 
nonzero = pos `disjoin` (pos . negate) 
zero = complement pos `conjoin` complement (pos . negate) 

Ich liebe Haskell!