Em Qui, 2007-01-11 às 16:14 +0100, minh thu escreveu:

you might want invistigate "heterogeneous lists" : in your case, it's "heterogeneous typle".

But aren't tuples always heterogeneous? Regards. -- malebria Marco Túlio Gontijo e Silva Correio (MSN): malebria@riseup.net Jabber (GTalk): malebria@jabber.org Telefone: 33346720 Celular: 98116720 Endereço: Rua Paula Cândido, 257/201 Gutierrez 30430-260 Belo Horizonte/MG Brasil

Em Qui, 2007-01-11 às 16:51 +0100, minh thu escreveu:

2007/1/11, Marco Túlio Gontijo e Silva :

...

Em Qui, 2007-01-11 às 16:14 +0100, minh thu escreveu:

...

you might want invistigate "heterogeneous lists" : in your case, it's "heterogeneous typle".

But aren't tuples always heterogeneous?

You're right but the fact you apply a function on both element of the tuple constrains them to have the same type. Thus the problem is reminiscent of heterogeneous lists: how can you make (i.e. wrap) two values of different type so they have (after being wrapped) the same type ?

I couldnt find the page I was refering but found this one: http://en.wikibooks.org/wiki/Haskell/Existentially_quantified_types Look at the part on heterogeneous list, the examples are the thing you want (but for a list, not for a tuple).

Oh two things: 1/ I'm a bad haskell programmers since I have not enough experience (so maybe I'm throwing you in the bad direction but I prefer to answer so you not have to wait to long...); 2/ It's a bit of a habit here to answer with quite involved material even when a noob asks something (which I don't know if you are or not). Thus maybe the real answer to your question is wether what you ask for is really the root of the problem (I can't answer for you).

Another way to do what you want if you just want to use the 'show' function above on some types (and not every instance of Show) is to wrap each type individually in a variant type something like this: data MyShowable = S String | B Bool myShow :: MyShowable -> String

Optionnaly you can then make MyShowable an instance of Show. This way is much more 'basic level' haskell than the wiki page above.

Thanks for your answers. I found the page of heterogeneous collections in haskell wiki: http://haskell.org/haskellwiki/Heterogenous_collections But my point was trying to do this without having to convert it to a homogeneous tuple by using Dynamic. I read a little of the wiki page, and it gave me some ideas: (with ghci -fglasgow-exts) let mapTuple :: forall c d e f. (forall a b. a -> b) -> (c, d) -> (e, f); mapTuple f (x, y) = (f x, f y) works fine, but when I run: Prelude> mapTuple show ("string", True) <interactive>:1:9: Couldn't match expected type `b' (a rigid variable) against inferred type `String' `b' is bound by the polymorphic type `forall a b. a -> b' at <interactive>:1:0-29 In the first argument of `mapTuple', namely `show' In the expression: mapTuple show ("string", True) In the definition of `it': it = mapTuple show ("string", True) Prelude> And: Prelude> mapTuple head (["string"], [True]) <interactive>:1:9: Couldn't match expected type `a' (a rigid variable) against inferred type `[a1]' `a' is bound by the polymorphic type `forall a b. a -> b' at <interactive>:1:0-33 Expected type: a -> b Inferred type: [a1] -> a1 In the first argument of `mapTuple', namely `head' In the expression: mapTuple head (["string"], [True]) Prelude> This seemed to "work": Prelude> mapTuple (const undefined) ("string", True) (*** Exception: Prelude.undefined Prelude> The problem is it only works with forall a b. a -> b functions. I tried with exits, but I got an error: Prelude> let mapTuple :: forall c d e f. (exists a b. a -> b) -> (c, d) -> (e, f); mapTuple f (x, y) = (f x, f y) <interactive>:1:43: parse error on input `.' Prelude> Thanks for any help. -- malebria Marco Túlio Gontijo e Silva Correio (MSN): malebria@riseup.net Jabber (GTalk): malebria@jabber.org Telefone: 33346720 Celular: 98116720 Endereço: Rua Paula Cândido, 257/201 Gutierrez 30430-260 Belo Horizonte/MG Brasil

Udo Stenzel wrote:

Marco T?lio Gontijo e Silva wrote:

...

is there a way to defined something as a map to use in tuples? I tried this:

mapTuple f (a, b) = (f a, f b)

But the type inferred to it is not as generic as I wanted:

mapTuple :: (t -> t1) -> (t, t) -> (t1, t1)

What you seem to want to do is impossible. Just want type would you want to assign to mapTuple? I bet you can't even express that in natural language, no wonder it's impossible in Haskell.

Maybe some of the type experts could pipe up, but couldn't you express that as an intersection type? mapTuple :: ((a -> b) ^ (c -> d)) -> (a,c) -> (b,d) http://www.cs.cmu.edu/~rwh/theses/pierce.pdf Greg Buchholz

On 12/01/07, Grady Lemoine wrote:

Is there anything in particular you're trying to accomplish? It seems like this is the type of thing you'd accomplish with typeclasses if you had a less general problem than you've presented. For example,

...

mapShowTuple :: (Show a, Show b) => (a, b) -> (String, String) mapShowTuple (x, y) = (show x, show y)

That said, it would be nice do be able to do something a little more general, but still with a specific typeclass, like

...

mapNumOpTuple :: (Num a, Num b) => (Num c => c -> c) -> (a, b) -> (a, b) mapNumOpTuple f (x, y) = (f x, f y)

(This unfortunately fails to typecheck; GHC chokes with "Illegal polymorphic or qualified type". On the other hand, I'm still pretty new to Haskell myself, so maybe someone else knows how to write this correctly without doing complex type hackery.)

It's close: {-# OPTIONS_GHC -fglasgow-exts #-} mapNumOpPair :: (Num a, Num b) => (forall c. Num c => c -> c) -> (a, b) -> (a,b) mapNumOpPair f (x,y) = (f x, f y)

It would also be nice to be able to generalize over all typeclasses, e.g. (pseudo-code here)

mapTypeclassOpTuple :: for all typeclasses C ((C a, C b) => (C c => c -> c) -> (a, b) -> (a, b))

but I don't even know how that would fit into Haskell's syntax. I suspect it's an idea that's been discussed, and I just don't know the term for it.

That's an interesting idea, typeclass variables. It would require a bit of a kind system for typeclasses, but that's not so hard. I somehow doubt it would get used all *that* much though. Can anyone think of a clever way to apply this? - Cale