Hi all,
it should be possible a call a function on all elements of the data
structure, to add and remove elements.
What I currently have:
the type class:
class Foo a where
hasId :: a -> Int -> Maybe a
a few instances:
data A = A deriving Show
instance Foo A where
hasId a 1 = Just a
hasId _ _ = Nothing
data B = B deriving Show
instance Foo B where
hasId a 2 = Just a
hasId _ _ = Nothing
data C = C deriving Show
instance Foo C where
hasId a 3 = Just a
hasId _ _ = Nothing
the data structure holding any instance of Foo, which itself is a
instance of Foo:
data Foos l r = Foos l r
| FooL l
| FooR r
| NoFoos deriving Show
instance (Foo l, Foo r) => Foo (Foos l r) where
hasId (Foos l r) id =
case (hasId l id, hasId r id) of
(Just l, Just r) -> Just $ Foos l r
(Just l, _ ) -> Just $ FooL l
(_ , Just r) -> Just $ FooR r
_ -> Nothing
combinator for Foos:
(+++) :: l -> r -> Foos l r
l +++ r = Foos l r
infixr 5 +++
Now I can write:
*Main> A +++ B +++ C +++ A
Foos A (Foos B (Foos C A))
*Main> (A +++ B +++ C +++ A) `hasId` 1
Just (Foos A (FooR (FooR A)))
Doesn't seem that nice. For every operation I would have to extend the
type class. After some operations the data structure contains many
dummy nodes (FooR, FooL).
Is there some nicer way?
Greetings,
Daniel
_______________________________________________
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe
