Got an idea, is it the right path? Are there bad consequences in using the extensions that are necessaries to make the code work?<br><br>class Mdk binary a | binary -> a where<br> mdk :: a -> b -> binary<br>instance Mdk (a,b) a where<br> mdk = ... :: a -> b -> (a,b)<br>instance Mdk (b, a) a where<br> mdk = ... :: a -> b -> (b, a)<br><br>then, however, even if it works, mdk will never be part of the other class i was working on, and at that point i'm a bit lost on the consequences of this...<br><br>Le samedi 4 juin 2016, Silent Leaf <<a href="mailto:silent.leaf0@gmail.com">silent.leaf0@gmail.com</a>> a écrit :<br>> I got a function, named mdk (don't ask). It happens it's a method of a class, as follows:<br>><br>> class C a where<br>>  mdk :: C b => a -> b -> (a, b)<br>><br>> yet i got another function, called so far mdk'<br>>  mdk' :: C b => b -> a -> (a, b)<br>><br>><br>> Say there are the following instances:<br>> instance C X where<br>>  mdk x b = ... :: C b => (X, b)<br>>  mdk' b x = ... :: C b => (X, b)<br>> instance C Y where<br>>  mdk y b = ... :: C b => (Y, b)<br>>  mdk' b y = ... :: C b => (Y, b)<br>><br>> if you get what's happening, mdk and mdk' are basically the same method, save for the final type-result, which is reversed, without data loss mind you (aka (A, B) and (B, A) could be the same type, if only i knew of a way to make a type in haskell without forcing the order (a kind of set or something).<br>> so, there are four cases:<br>> input have types, in this order, X and Y, and expected output is (X, Y): then mdk from X's instance of C is called/must be used;<br>> input have types Y and X, output (X, Y): X's mdk'<br>> input X and Y, output (Y, X): Y's mdk<br>> input Y and X, output (Y, X): Y's mdk'<br>><br>> it might seem confusing, but all amounts to the issue that even though (Y, X) is strictly equivalent, in my program, to (X, Y), in principle haskell differentiate the types.<br>> thus i have to write two versions of mdk for each type, even though the methods "X's mdk" and "Y's mdk'" are identical, and same for the two other methods.<br>> indeed:<br>> mdk :: C b => X -> b -> (X, b)<br>> mdk' :: C b => b -> Y -> (Y, b)<br>> are identical signatures, if in the first one you replace `b` with Y, and in the latter you replace `b` with X, and ofc if you consider (X,Y) == (Y,X).<br>><br>> only one of those two methods should be enough to handle the job, and be chosen by the compiler on the sole value of the type of the first variable; but the fact both methods return tuples of "mirrored" types, crushes that. if i only write `mdk` instances, as soon as the compiler will meet this following signature:<br>>  mdk :: a -> b -> (b, a)<br>> it will crash an exception, because mdk's original signature has for output value a tuple whose first type should here be `a`, because it's meant to be the type of the first argument, not the second.<br>><br>> thus, at last my question: can i tell the compiler to consider (b, a) and (a, b) as identical types (don't worry it's not really a tuple in my program, but it's equivalent)?<br>> if not, can i make an overloading of mdk so it accepts both a->b->(a,b) and a->b->(b,a)?<br>><br>> hope i didn't lose anyone. if so, do tell me, i'll try to clarify.<br>><br>> thanks in advance of the time spent trying to understand my problem!