unsafe parsing

[Kenny Lu Zhuo Ming]

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