Interesting. You want to control a data type used *inside* an algorithm from outside. Here's a smaller version: foo :: String -> String foo s = show (read s) This is ambiguous; what type should 'read' return? Your idea: pass in that type via a proxy value: foo :: (Read a, Show a) => a -> String -> String foo p s = show (read s `asTypeOf` p) Now you can say foo (undefined :: Int) "34" and it'll work. A neater way to do this with GHC is to use scoped type variables: foo :: (Read a, Show a) => a -> String -> String foo (p::a) s = show (read s :: a) One reason this is neater is that it scales up better when you want to pass a type constructor instead of a type. First define a data type with no constructors, and a phantom type arg data Proxy (a :: * -> *) Now you can write a function like this f :: (MArray a ix e) => Proxy a -> .... f (p :: Proxy a) ... = do { (arr :: a ix e) <- newArray ... The type variable 'a' is bound by the (Proxy a) pattern, and scopes over the body. The type variables 'ix' and 'e' in the do-binding are bound right there (since they aren't already in scope). Another use for phantom types! Simon | -----Original Message----- | From: Hal Daume III [mailto:hdaume@ISI.EDU] | Sent: 03 November 2002 19:31 | To: Haskell Mailing List | Subject: getting the right types | | Hi all, | | I have a function which essentially looks like this: | | f my_data = do | a1 <- newArray ... | ... | a2 <- newArray ... | g my_data a1 a2 | | where f is a monadic operation essentially of type 'a -> m a'. The | problem is that when this function isn't given a type signature, you get | something like: | | f :: (MArray a1 p e, MArray a2 p e) => t | | where a1 and a2 aren't bound in t. Now, I could provide a type signature | on the array expressions, something like: | | ... (a1 :: IOArray Int Int) <- newArray ... | | but i would like to be able to use unboxed arrays when possible, and i | don't want to bind the funtion to be in IO. My current solution is to | define: | | data ArrayType arr prob = forall ix . ArrayType (arr ix prob) | asArray :: arr ix prob -> ArrayType arr prob -> arr ix prob | a `asArray` _ = a | | Sort of like asTypeOf. Then, I change f to: | | f :: (MArray arr p e) => ArrayType arr p -> t -> m t | f arr_type ... = ... | | And inside f I have a function: | | newArray_arr bnds init = | do a <- newArray bnds init | return (a `asArray` arr_type) | | This enables me to create arrays of arbitrary representation with the same | values but different indices (which is important). | | However, this strikes me as horribly hackish. Is there some better way to | do this? | | - Hal | | -- | Hal Daume III | | "Computer science is no more about computers | hdaume@isi.edu | than astronomy is about telescopes." -Dijkstra | www.isi.edu/~hdaume | | _______________________________________________ | Haskell mailing list | Haskell@haskell.org | http://www.haskell.org/mailman/listinfo/haskell