(Note that the term "nested data type" also/already carries the meaning "non-regular data type", an example being data PerfectBinaryTree a = One a | Succ (PerfectBinaryTree (a,a)) ) Thomas Girod wrote:
recently I was trying to represent complex data by defining several datatypes and nesting them, such as
data Foo = Foo { foo :: Bar } deriving (Eq,Show) data Bar = Bar { bar :: Int } deriving (Eq,Show)
To change only a part of the data, syntactic sugar is quite convenient. But it seems to be quite painful with nested datatypes.
b = Bar 10 f = Foo b
foobar :: Int -> Foo -> Foo foobar i f = let nb = (foo f){bar = i} in f{foo = nb}
So, my question is : is there a nifty way to modify data within a nested datatype, similar to the f{foo = bar} style ? If not, anyone is using some kind of workaround for this ?
There is a nifty way, called "functional references". They're a pair of get and set functions data Ref s a = Ref { get :: s -> a, set :: a -> s -> s } The nice thing about them is that we can compose them like functions o :: Ref b c -> Ref a b -> Ref a c f `o` g = Ref (get f . get g) (\c a -> set (set c f $ get g a) g a) The example becomes data Foo = Foo Bar data Bar = Bar Int foo :: Ref Foo Bar foo = Ref (\(Foo x) -> x) (\x (Foo _) -> Foo y) bar :: Ref Bar Int bar = Ref (\(Bar x) -> x) (\x (Bar _) -> Bar x) foobar :: Ref Foo Int foobar = bar `o` foo See also http://luqui.org/blog/archives/2007/08/05/ haskell-state-accessors-second-attempt-composability/ and Sander Evers, Peter Achten, and Jan Kuper. "A Functional Programming Technique for Forms in Graphical User Interfaces". http://www.st.cs.ru.nl/papers/2005/eves2005-FFormsIFL04.pdf Writing getter and setter functions by hand can be tedious but somebody already automated this with Template Haskell or other other preprocessing tools. Regards, apfelmus