unsafe parsing

30 Apr 2003

      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

module Test where

data Content = C1 Char
      | C2 String deriving Eq

class MyType a where
    parse :: Content -> (Maybe a)

data A = A deriving (Show,Eq)

instance MyType A where
    parse (C1 'A') = Just A
    parse _ = Nothing

data B = B deriving (Show,Eq)

instance MyType B where
    parse (C1 'B') = Just B
    parse _ = Nothing

data Cons x xs = Cons x xs deriving Show

instance (MyType x,MyType xs) => MyType (Cons x xs) where
    parse (C2 (x:xs)) =  let maybehd = parse (C1 x) in
        case maybehd of 
        Just hd ->
     let maybetl = parse (C2 xs) in
         case maybetl of 
         Just tl ->
      Just ((Cons hd) tl)
         Nothing -> Nothing
        Nothing -> Nothing
    parse _ = Nothing

data Nil = Nil deriving (Show,Eq)

instance MyType Nil where 
    parse (C2 [])  = Just Nil
    parse _ = Nothing

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
Hugs session for:
/usr/share/hugs/lib/Prelude.hs
Test.hs
Type :? for help
Test> parse (C2 "A") :: Maybe (Cons A Nil)
Just (Cons A Nil)

Kenny Lu Zhuo Ming

Derek Elkins

Kenny Lu Zhuo Ming

Derek Elkins

tags

participants (2)