Comments on: Haskell Records Considered Grungy

By: Max Nanasy

Max Nanasy — Sun, 18 Jan 2009 06:49:44 +0000

You still have some errors in the way you wrote your pattern matches:

> name (Bird value, _) = value
should be
> name (Bird value _) = value

Commas are only for record syntax and some syntactically unique constructors, such as lists and tuples.

By: Jimmy H

Jimmy H — Sun, 30 Nov 2008 19:14:08 +0000

I find it ironic that you complain about record extraction being prefix rather than postfix, and then later complain that record update isn’t available in point-free form, and indicate that if Haskell were saner, it would also be prefix…

The “functional orthogonality” of Haskell that you mention is its best feature in my book. updateWings = {wings = 3} is just changing the semantics of record update to something in line with the rest of the language.

For the people who want “update field container value = …”, what should its type be?

By: Idetrorce

Idetrorce — Sun, 16 Dec 2007 06:27:24 +0000

very interesting, but I don’t agree with you
Idetrorce

By: josh

josh — Fri, 27 Apr 2007 18:43:40 +0000

I think the { wings = x } issue would be less of a problem if you could write “update field container value = container { field = value }”. But of course you can’t.

By: batterseapower

batterseapower — Fri, 27 Apr 2007 13:05:15 +0000

Saizan, thanks for your comment! You are indeed right that my pattern matches were totally off, I’ve fixed that (maybe it’ll teach me to make posts without a compiler available!).

However, my point about changeWings stands: what I’m trying to say is that { wings = x } is not actually a function, it’s something a bit special that has meaning only when a record value is put before it. It’s ugly because it breaks the nice functional orthogonality of other Haskell constructions. I probably should have made this clearer!

By: Saizan

Saizan — Fri, 27 Apr 2007 12:48:57 +0000

your desugaring examples are quite wrong:
> name :: Bird -> String
> name (value, _) = value
should be written:
> name (Bird value _) = value

Also you can indeed write a changeWings function:
> changeWings :: Integer -> Bird -> Bird
> changeWings x b = b{wings = x }

the problem is that you can’t write something like this:
> changeField field v b = b{field = v}

By: batterseapower

batterseapower — Fri, 27 Apr 2007 12:45:54 +0000

Thanks a lot for all the great comments! I’ll be sure to check out those two papers. And yeah, the module system is one (considerably cleaner, it must be said!) way to get around the namespace problem, but it’s still not perfect . Heres hoping Haskell’ solves all this for us!

By: Logan Capaldo

Logan Capaldo — Fri, 27 Apr 2007 11:57:10 +0000

An alternative hack (which I’m sure you are aware of) would be something like:

module Bird where
data Bird = Bird { name :: String, wings :: Integer }

…

module Person where
data Person = Person { name :: String, age :: Integer }

…

module Main where
import qualified Bird
import qualified Person — heh
…
> Person.name examplePerson
…
> Bird.name exampleBird
…

To make it a little less wordy:
import qualified Bird as B
…
> B.name exampleBird

By: Neil Mitchell

Neil Mitchell — Fri, 27 Apr 2007 10:30:14 +0000

Daan Leijen, “Extensible records with scoped labels” – http://www.cs.ioc.ee/tfp-icfp-gpce05/tfp-proc/21num.pdf

That paper may be of interest to you, its a very different, and very neat way of defining records.

By: Josef Svenningsson

Josef Svenningsson — Fri, 27 Apr 2007 09:52:56 +0000

I agree with you that Haskell’s record system is not the strongest part of the language. It’s a hack that was added because it was easy to do so and gave a way to refer to components of a constructor by name instead of by position. So the power to weight ratio is pretty high but it still is something of a wart.

The best proposals for records that I have ever seen is that by Daan Leijen. “Extensible records with scoped labels”(http://www.cs.uu.nl/~daan/download/papers/scopedlabels.pdf) I wish some Haskell implementation would implement that so that one could play with it. It would also be very nice to have in Haskell’ but that may be too much to hope for.