Well, it seems that it doesn't quite help here. Because the resulting existentially qualifed typess are always in form of variable, there is no way I can apply a function which requires static type, for example: data A = A deriving Show data B = B deriving Show data Cons x xs = Cons x xs deriving Show data Nil = Nil deriving Show class XTERM u where xtval:: u -> Char instance XTERM A where xtval _ = 'A' instance XTERM B where xtval _ = 'B' class XSEQ u where xsval:: u -> String instance XSEQ Nil where xsval _ = [] instance (XTERM v, XSEQ w) => XSEQ (Cons v w) where xsval _ = (xtval (undefined::v)):(xsval (undefined::w)) data BTERM = forall u. (XTERM u) => BTERM u xtmake 'A' = BTERM A xtmake 'B' = BTERM B xtmake _ = error "" data BSEQ = forall u. (XSEQ u) => BSEQ u xsmake [] = BSEQ Nil xsmake (x:xs) = case (xtmake x) of (BTERM (t::tt)) -> case (xsmake xs) of (BSEQ (s::ss)) -> BSEQ ((Cons t s)::(Cons tt ss)) class Funny a b | a->b where funny :: a->b instance (Funny rest rest') => Funny (Cons A rest) (Cons B rest') where funny (Cons A rest) = Cons B (funny rest) instance Funny Nil Nil where funny Nil = Nil this funny function will turn a sequence of A in the a sequence of B. when I apply it to the (xsmake "AA"), ghc complains *ABSEQ> case (xsmake "AA") of (BSEQ u::t) -> funny u :1: Could not deduce (Funny u b) from the context (XSEQ u) Probable fix: Add (Funny u b) to the existential context of a data constructor arising from use of `funny' at :1 In a case alternative: funny u It seems at somepoint I need a unsafe type casting. Kenny ----- Original Message ----- From: "Derek Elkins" <ddarius@hotpop.com> To: "Kenny Lu Zhuo Ming" <haskellmail@yahoo.com.sg> Cc: <haskell@haskell.org> Sent: Wednesday, April 30, 2003 9:47 PM Subject: Re: unsafe parsing
On Wed, 30 Apr 2003 15:29:04 +0800 "Kenny Lu Zhuo Ming" <haskellmail@yahoo.com.sg> wrote:
Hi all,
I am currently write a program to type a dynamic string consist of 'A' or 'B'
for short, it works in this manner: for 'A', it returns A :: A for 'B', it returns B :: B for "A", it returns Cons A Nil :: Cons A Nil for "AB", it returns Cons A (Cons B Nil) :: Cons A (Cons B Nil) ...
The problem is I have to specifically annotate the output type, which is unaffordable, because I might have arbitrary-long string, and I have infinitely many possible singleton types. It seems it is impossible to do it in a type-safe way. Anyone of you have any idea to walk around that?
Regards, Kenny
Is there any reason [Either A B] couldn't be used? Otherwise, you may want to look at the thread "polymorphic stanamically typed balanced trees" on this list (or haskell-cafe), and/or SimulatingDependentTypes on the Haskell Wiki (it's linked from haskell.org). SimulatingDependentTypes also has a link to the aforementioned thread.
_______________________________________________ Haskell mailing list Haskell@haskell.org http://www.haskell.org/mailman/listinfo/haskell