Ability to use record fields for automatic derivation of user-defined classes.
I propose that the compiler be empowered to automatically derive a user-defined class when a data type has fields that match (in both name and type) methods sufficient for a minimal complete definition of the class. (There is some overlap between this idea and the much larger and more contentious issue of extensible records generally.)
I am relatively new to Haskell, but have quickly run into the problem of field namespacing. As a simple example, suppose we are creating a game with data types for Room and Item, and values of each of these types will have a short name and a long description (possibly among other fields not detailed here). Currently, we must name our fields differently, as in:
-- ugh! prefixing the field names is ugly and tedious
data Room = Room { rname :: String, rdescribe :: String, item :: Maybe Item }
data Item = Item { iname :: String, idescribe :: String, value :: Int }
Classes seem a natural solution to this problem, but then we must either have superfluous field names or drop the use of field names altogether:
-- extracting a common interface as a class makes sense
type Desc d where
name :: d -> String
describe :: d -> String
-- but now we either keep the ugly prefixed fields or drop fields entirely
data Room = Room String String (Maybe Item)
data Item = Item String String Int
-- furthermore, it is tedious to implement these trivial observers
instance Desc Room where
name (Room n _ _) = n
describe (Room _ d _) = d
instance Desc Item where
name (Item n _ _) = n
describe (Item _ d _) = d
My proposal is to allow the compiler to rely on fields in order to automatically derive a user-defined class. This solves a couple of problems in a way that (I hope) is not excessively complex to implement. Such a feature would allow us to write code like the following:
-- class as a common interface still feels natural
type Desc d where
name :: d -> String
describe :: d -> String
-- now we get shared field names and let the compiler do some of the work
data Room = Room { name :: String, describe :: String, item :: (Maybe Item) }
deriving Desc
data Item = Item { name :: String, describe :: String, value :: Int }
deriving Desc
Obviously, there are a couple of restrictions here:
- fields of the same name in different records must have the same type
- fields of the same name in different records are still ambiguous (no different than the current situation) if we do //not// derive a class that declares those field names
- this is //not// intended to be a general solution for either extensible records or deriving classes automatically, it is very limited in scope
P.S. This is my first Ticket and attempt to get involved in the community, and I'm not yet sure of the correct tags to use. Please be gentle. :)
Trac metadata
Trac field | Value |
---|---|
Version | 7.10.3 |
Type | FeatureRequest |
TypeOfFailure | OtherFailure |
Priority | normal |
Resolution | Unresolved |
Component | Compiler |
Test case | |
Differential revisions | |
BlockedBy | |
Related | |
Blocking | |
CC | |
Operating system | |
Architecture |