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)