Эти два комбинатора уже доступны в Haskell?

Question

мне нужно двоичные комбинаторов типа

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

или, может быть,

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

(хотя это было бы просто быть foldr1 из первых, и я обычно нужно только объединить две булевы функции.)

Являются ли эти встроенные?

---

Если нет, то реализация проста:

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

или, возможно,

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

Hoogle поворачивает вверх ничего, но иногда его поиск не обобщать должным образом. Любая идея, если они встроены? Могут ли они быть построены из частей существующей библиотеки?

Если они не встроены, вы можете предлагать новые имена, потому что эти имена довольно плохи. На самом деле, это главная причина, я надеюсь, что они являются встроенный.

Answer 1

Control.Monad определяет instance Monad ((->) r), так

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

Вы могли бы сделать то же самое с Control.Applicative.liftA2.

---

Не серьезно предложить, но ...

 
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

Я не знаю встроенных, но мне нравятся имена, которые вы предлагаете.

getCoolNumbers = filter $ either even (< 42) 

В качестве альтернативы можно было бы использовать символ оператора в дополнение к классам для альтернатив.

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

Answer 3

Это не является встроенным, но альтернативой Я предпочитаю использовать классы типа для обобщать булевы операции предикатов любого arty:

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) 

Я люблю Haskell!