On Mon, Jan 02, 2006 at 01:53:51PM +0000, Joel Reymont wrote:
Say you turned automatic generation of accessor functions off. You would still need accessor functions, right? What would they look like if you were to write them by hand?
They could look identical if you wrote them by hand, but you could also choose to put them in a type class. So you might write data Foo = Foo { foo :: Int } data FooBar = FooBar { foo :: Int, bar :: String } class Foo f where foo :: f -> Int instance Foo Foo where foo (Foo { foo=f }) = f instance Foo FooBar where foo (FooBar { foo=f }) = f bar :: FooBar -> String bar (FooBar { bar=b }) = b I believe it wouldn't be hard to write TH (or SYB, or DrIFT or something else?) code to do this sort of thing automatically. Technically, you don't need accessor functions, as you can get by with pattern matching, which is what this proposal is about. If we remove the accessor functions, they can always be written by hand, and we separate the record-field namespace from the function namespace. One might argue that updater functions are as important as accessor functions, but they aren't defined automatically in Haskell 98. One might prefer to define data Foo = Foo { foo :: Int } set_foo :: Foo -> Int -> Foo get_foo :: Foo -> Int and perhaps even modify_foo :: Foo -> (Int -> Int) -> Foo which would eliminate the need for the (clumsy, in my opinion) { foo=f } syntax. -- David Roundy http://www.darcs.net