Hi All, I'm trying to write a generic curry (& uncurry) function that works for functions of any arity. I have a couple solutions that nearly work, both involving type classes. Here's the first one: class Curry tupled curried where genericCurry :: tupled -> curried genericUncurry :: curried -> tupled The base case is obvious: instance Curry ((a,b) -> c) (a -> b -> c) where genericCurry f x y = f (x,y) genericUncurry f' (x,y) = f' x y However, the inductive case is more tricky. We cannot generically create tuples of arbitrary size so we'll have to make do with left (or right) nested pairs. This nesting leads to problems later and for starters requires overlapping instances: instance Curry ( (b,c) -> d) ( b -> c -> d) => Curry ((a,(b,c)) -> d) (a -> b -> c -> d) where genericCurry f a b c = f (a,(b,c)) genericUncurry f (a,(b,c)) = f a b c This works, but when we come to use it we often run into cases where the type checker complains with messages such as: No instance for (Curry ((Int, Int) -> Int) (a -> b -> Int)) I guess that this is because it fails to be able to convince itself that a & b are Int, in which case there would be an instance. This can be solved by supplying enough type annotations, however this is annoying and part of the point of a generic curry is that we don't know the arity of the function to which we are applying it. So I thought that functional dependencies might help because the curried type should uniquely determine the uncurried type (and vice versa). However if I change the class declaration to: class Curry tupled curried | tupled -> curried, curried -> tupled where genericCurry :: tupled -> curried genericUncurry :: curried -> tupled Then the compiler complains about my instance declarations: Functional dependencies conflict between instance declarations: ./Curry.hs:11:0: instance Curry ((a, b) -> c) (a -> b -> c) ./Curry.hs:16:0: instance (Curry ((b, c) -> d) (b -> c -> d)) => Curry ((a, (b, c)) -> d) (a -> b -> c -> d) I don't fully understand why this is the case, but it is to do with the nested pairing, because individual instance declarations for 3-tuples, 4-tuples work find. Any insight or suggestions would be interesting. Duncan