Hi,
On 28/08/13 21:05, Wvv wrote:
> Let we have data in one module as this:
>
> data Person = Person { personId :: Int, name :: String }
> data Address a = Address { personId :: Int, address :: String , way ::
> a}
>
> It was discussed a lot in topics "OverloadedRecordFields"
>
> This is an alternative:
> Let we have polymorphic typeclass:
>
> class Record{f} a b | a -> b where
> f :: a -> b
>
> so, compiler could create instances for our data as:
>
> instance Record{personId} Person Int where
> personId (Person x _) = x
>
> instance Record{personId} (Address a) Int where
> personId (Address x _ _) = x
>
> instance Record{way} (Address Int) Int where
> way (Address _ _ x) = x
>
> and we could use this:
>
> p:: Record {personId} r Int => r -> Int
> p = personId
>
>
> What do you think about this?
This more or less is what I am implementing as the
OverloadedRecordFields extension. I define the following:
class t ~ GetResult r f => Has r (f :: Symbol) t where
getField :: proxy f -> r -> t
type family GetResult (r :: *) (f :: Symbol) :: *
instance Has Person "personId" Int where
getField _ (Person x _) = x
The `Has` class corresponds to your `Record` class, except it uses a
type family instead of a functional dependency. Moreover, Haskell
doesn't allow classes to be polymorphic in the names of their methods,
so a single method `getField` is used.
You can find out more about the design on the GHC wiki, which also has
links to the development repositories and a prototype implementation:
http://ghc.haskell.org/trac/ghc/wiki/Records/OverloadedRecordFields/Plan
Regards,
Adam
_______________________________________________
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe
