Question

I just uncovered this confusion and would like a confirmation that it is what it is. Unless, of course, I am just missing something.

Say, I have these data declarations:

data VmInfo = VmInfo {name, index, id :: String} deriving (Show)
data HostInfo = HostInfo {name, index, id :: String} deriving (Show)

vm = VmInfo "vm1" "01" "74653"
host = HostInfo "host1" "02" "98732"

What I always thought and what seems to be so natural and logical is this:

vmName = vm.name
hostName = host.name

But this, obviously, does not work. I got this.

---

Questions

So my questions are.

• When I create a data type with record syntax, do I have to make sure that all the fields have unique names? If yes – why?

• Is there a clean way or something similar to a “scope resolution operator”, like :: or ., etc., so that Haskell distinguishes which data type the name (or any other none unique fields) belongs to and returns the correct result?

• What is the correct way to deal with this if I have several declarations with the same field names?

---

As a side note.

In general, I need to return data types similar to the above example.
First I returned them as tuples (seemed to me the correct way at the time). But tuples are hard to work with as it is impossible to extract individual parts of a complex type as easy as with the lists using “!!”. So next thing I thought of the dictionaries/hashes.
When I tried using dictionaries I thought what is the point of having own data types then?
Playing/learning data types I encountered the fact that led me to the above question.
So it looks like it is easier for me to use dictionaries instead of own data types as I can use the same fields for different objects.

---

Can you please elaborate on this and tell me how it is done in real world?

Answer 1

Haskell record syntax is a bit of a hack, but the record name emerges as a function, and that function has to have a unique type. So you can share record-field names among constructors of a single datatype but not among distinct datatypes.

What is the correct way to deal with this if I have several declarations with the same field names?

You can’t. You have to use distinct field names. If you want an overloaded name to select from a record, you can try using a type class. But basically, field names in Haskell don’t work the way they do in say, C or Pascal. Calling it “record syntax” might have been a mistake.

But tuples are hard to work with as it is impossible to extract individual parts of a complex type

Actually, this can be quite easy using pattern matching. Example

smallId :: VmInfo -> Bool
smallId (VmInfo { vmId = n }) = n < 10

As to how this is done in the “real world”, Haskell programmers tend to rely heavily on knowing what type each field is at compile time. If you want the type of a field to vary, a Haskell programmer introduces a type parameter to carry varying information. Example

data VmInfo a = VmInfo { vmId :: Int, vmName :: String, vmInfo :: a }

Now you can have VmInfo String, VmInfo Dictionary, VmInfo Node, or whatever you want.

Summary: each field name must belong to a unique type, and experienced Haskell programmers work with the static type system instead of trying to work around it. And you definitely want to learn about pattern matching.