How to compose `not` with a function of arbitrary arity?

Question

When I have some function of type like

f :: (Ord a) => a -> a -> Bool f a b = a > b 

I should like make function which wrap this function with not.

e.g. make function like this

g :: (Ord a) => a -> a -> Bool g a b = not $ f a b 

I can make combinator like

n f = (\a -> \b -> not $ f a b) 

But I don't know how.

*Main> let n f = (\a -> \b -> not $ f a b) n :: (t -> t1 -> Bool) -> t -> t1 -> Bool Main> :t n f n f :: (Ord t) => t -> t -> Bool *Main> let g = n f g :: () -> () -> Bool 

What am I doing wrong?

And bonus question how I can do this for function with more and lest parameters e.g.

t -> Bool t -> t1 -> Bool t -> t1 -> t2 -> Bool t -> t1 -> t2 -> t3 -> Bool 

Answer 1

Actually, doing arbitrary arity with type classes turns out to be incredibly easy:

module Pred where  class Predicate a where   complement :: a -> a  instance Predicate Bool where   complement = not  instance (Predicate b) => Predicate (a -> b) where   complement f = \a -> complement (f a)     -- if you want to be mysterious, then   -- complement = (complement .)   -- also works  ge :: Ord a => a -> a -> Bool ge = complement (<) 

Thanks for pointing out this cool problem. I love Haskell.