Patrick Browne wrote:
Hi,
I am trying to understand the data type declaration below.
What is the relation between class C3 and the data type Address below?
Where is such a technique used?
OK, let's see what we can come up with...
module A where
data Person = Person String Integer deriving Show
data Employee = Employee String Integer deriving Show
Person and Employee are identical types, just with different names.
class C1 c1 where
age :: c1 -> Integer
The "age" function works for any type declared to be an instance of C1.
instance C1 Person where
age(Person "P1" 1) = 1
instance C1 Employee where
age(Employee "E1" 1) = 1
Person and Employee are both declared to be instances of C1.
Incidentally, those declarations look *very* dubious. What the first one
says, for example, is that if a person is called "P1" and their age is
1, then return 1. If the name is not "P1" or the age is not 1, crash.
class C1 c2 => C2 c2 where
name :: c2 -> String
The "name" function works for any type declared to be an instance of C2.
Any such type must also be an instance of C1.
instance C2 Person where
name(Person "P2" 1) = "P2"
instance C2 Employee where
name(Employee "E2" 1) = "E2"
Person and Employee are both instances of C2 (which is allowed, since
they are already instances of C1).
Again, the instance declarations look highly dubious.
class C2 c3 => C3 c3 a where
address :: c3 -> a
This is not valid in Haskell '98. This is actually a type system
extension known as "multi-parameter type classes", which do not even
vaguely correspond to anything in normal OOP. (Except for being very
slightly similar to generics, perhaps.)
Here C3 is a relation *between* two types (type "c3" and type "a"). For
any so-related types, the "address" fucntion can map one type to the
other. (Presumably by returning the contents of an address field...)
This is a very odd way to define such an action.
instance C3 Person String where
The types Person and String are related by C3 as described above.
However, calling "address" will crash immediately (since no
implementation is supplied).
-- ** What are the semantics or purpose of this construct.
-- ** Is the type declared in the context of a class.
data C3 c3 a => Address c3 a = Address c3 a
This defines a new type named "Address". The type has two type
parameters ("c3" and "a"), and a value of this type has two fields.
In other words, if you say "Address Rock Stone", then an Address value
has two fields, the first one of type Rock, the second of type Stone.
Also, the type parameters are required to be related by C3. So unless
you write "instance C3 Rock Stone", you cannot say "Address Rock Stone".
It would be a type error. However, since "instance C3 Person String"
exists above, you may say "Address Person String".
instance C3 Person (Address String String) where
This says that the type "Person" and the type "Address String String"
are related by C3 as well - which is amusing, given that "Address String
String" is a type error due to the fact that we don't have "instance C3
String String"...
In short, this big tangle of code shouldn't even compile, and if it
does, I have no clue what in the name of God it actually does. It
appears to have been written by somebody who has no idea what they're doing.
If you want to know what a specific language construct does, or why
you'd use it, or which way you'd attack a specific problem, I (and
everybody else here) can try to offer some explanation. But the code
you're showing me doesn't really make any sense.
_______________________________________________
Haskell-Cafe mailing list
[email protected]
http://www.haskell.org/mailman/listinfo/haskell-cafe
