¿Estos dos combinadores ya están disponibles en Haskell?

Question

necesito combinadores binarios del tipo

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

o tal vez

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

(aunque esto no sería más que la foldr1 de la primera, y por lo general sólo es necesario combinar dos funciones booleanas.)

¿Están incorporados?

---

Si no es así, la implementación es simple:

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

o tal vez

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

Hoogle vuelve a nada, pero a veces su búsqueda no generalizar correctamente. Alguna idea si estos están incorporados? ¿Se pueden construir a partir de piezas de una biblioteca existente?

Si no están incorporados, puede sugerir nuevos nombres, porque estos nombres son bastante malos. De hecho, esa es la razón principal por la que espero que sean incorporados.

Answer 1

Control.Monad define un instance Monad ((->) r), por lo

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

que podría hacer lo mismo con Control.Applicative.liftA2.

---

no quiere decir en serio, pero ...

 
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

No sé builtins, pero me gustan los nombres que usted propone.

getCoolNumbers = filter $ either even (< 42) 

Alternativamente, se podría pensar en un símbolo de operador además de tipos de clases para las alternativas.

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

Answer 3

No es una orden interna, pero la alternativa prefiero es el uso de las clases de tipos de generalizar las operaciones booleanas a los predicados de cualquier 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) 

I love Haskell!