import Control.Applicative (Const(..), (<$>)) import Control.Monad.Identity (Identity(..)) import Data.Functor.Compose (Compose(..))

There has been a lot of interest in record proposals for Haskell lately. Many people want to integrate lenses with the record system, but one problem is that most lens libraries are incompatible with polymorphic record updating.

Here is a simple example of polymorphic record updating. Suppose we make the following simple polymorphic record type.

data Pair a b = Pair {pi1 :: a, pi2 :: b} deriving Show examplePair :: Pair Int Char examplePair = Pair {pi1 = 1, pi2 = 'b'}

In Haskell, we can then update `examplePair`

(by making an updated copy) as follows.

λ> examplePair {pi1 = "a"} Pair {pi1 = "a", pi2 = 'b'}

Notice the type has changed from `Pair Int Char`

to `Pair String Char`

.
This is what we mean by polymorphic record updates.
Polymorphic record updates allows records with type parameters to be updated in such a way that their type parameters change.
Most lens libraries do not support polymorphic record updates.

However, I recently realized that van Laarhoven style lenses do support polymorphic record updates. In fact, they support it right out of the box. We would have seen this in Twan’s original blog post had he not given a type alias for them.

Imagine this alternative history of Haskell.
It is 1996, and the Haskell committee is about to introduce record syntax into Haskell 1.3.
However, a (very) young Twan van Laarhoven joins the Haskell committee with fresh ideas.
Instead of introducing field names as projection functions `pi1 :: Pair a b -> a`

and `pi2 :: Pair a b -> b`

,
he pursuade them to give field names the following unusual definitions instead.

pi1 :: Functor f => (a -> f a') -> Pair a b -> f (Pair a' b) pi1 f (Pair a b) = (\x -> Pair x b) <$> f a pi2 :: Functor f => (b -> f b') -> Pair a b -> f (Pair a b') pi2 f (Pair a b) = (\x -> Pair a x) <$> f b

These are the van Laarhoven lenses for the first and second fields of `Pair`

.
The Haskell committee adds some new Prelude functions to support these lenses.

-- getter infixl 8 ^. (^.) :: a -> ((b -> Const b b') -> a -> Const b a') -> b x ^. l = getConst $ l Const x -- modifier infixr 4 %= (%=) :: ((b -> Identity b') -> a -> Identity a') -> (b -> b') -> a -> a' l %= f = runIdentity . l (Identity . f) -- setter infixr 4 ^= (^=) :: ((b -> Identity b') -> a -> Identity a') -> b' -> a -> a' l ^= v = l %= (const v)

Now we can do field access and simple polymorphic field updates:

λ> examplePair ^. pi1 1 λ> examplePair ^. pi2 'b' λ> (pi1 ^= "a") examplePair Pair {pi1 = "a", pi2 = 'b'} λ> (pi1 ^= "a") . (pi2 %= fromEnum) $ examplePair Pair {pi1 = "a", pi2 = 98}Moreover, we get lens composition. In fact, van Laarhoven lenses compose with the composition function

`(.)`

and `id`

is the identity lens.
Suppose we define the following nested record.
nestedPair :: Pair (Pair Int Char) String nestedPair = Pair {pi1 = examplePair, pi2 = "FTW!"}Now we can access and update nested elements of this pair

λ> nestedPair ^. pi1 ^. pi2 'b' λ> nestedPair ^. (pi1 . pi2) 'b' λ> (pi1 . pi2 ^= ["nested", "polymorphic", "update"]) nestedPair Pair {pi1 = Pair {pi1 = 1, pi2 = ["nested","polymorphic","update"]}, pi2 = "FTW!"}and we can do useless things with the identity lens.

λ> examplePair ^. id Pair {pi1 = 1, pi2 = 'b'} λ> (id ^= ()) examplePair ()

Further more, users can make their own lenses for Data.Map, etc. that are compatible with the prelude lens operations as long as they follow the two van Laarhoven lens laws:

lens Identity === Identity lens (composeCoalgebroid f g) === composeCoalgebroid (lens f) (lens g) where composeCoalgebroid :: (Functor f, Functor g) => (b -> f c) -> (a -> g b) -> a -> (Compose g f) c composeCoalgebroid f g a = Compose $ f <$> g a

There are some caveats with this approach though. It only natively supports simple polymorphic record update. In Haskell, you can do complex polymorphic updates. For instance, with the following record

data Complicated a b = Complicated {field1 :: a, field2 :: a, field3 :: b} deriving Show complexExample :: Complicated Int Char complexExample = Complicated {field1 = 1, field2 = 2, field3 = 'c'}you can polymorphically update

`field1`

and `field2`

together:
λ> complexExample {field1 = False, field2 = True} Complicated {field1 = False, field2 = True, field3 = 'c'}

However it is not possible to compose the polymorphic van Laarhoven lenses `field1`

and `field2`

to do this.
As consolation, it is possible to hand create a van Laarhoven lens to do the update.

handmadeLens :: Functor f => ((a, a) -> f (a', a')) -> Complicated a b -> f (Complicated a' b) handmadeLens g (Complicated f1 f2 f3) = (\(n1, n2) -> Complicated n1 n2 f3) <$> g (f1, f2)

λ> (handmadeLens ^= (False, True)) complexExample Complicated {field1 = False, field2 = True, field3 = 'c'}

It might be possible to create syntax that derives these complex lenses just in time from a sequence of field names.

In conclusion, contrary to popular belief, polymorphic record updates are possible with lenses. None of this post has addressed the namespace issue with records, nor was it intended to be a record proposal for Haskell. However, it might be possible to incorporate this with a namespace proposal to somehow get a nice record syntax with first-class lenses and at least simple polymorphic record updates.