A lens solves the problem of reading from, and updating, a deeply nested record structure in a purely functional way, but without getting mired in ugly, deeply nested and bracketed code. Anyway, the talk got me interested in finding out what was available with Scala. There seem to be two main contenders at the moment - from scalaz 7 and shapeless. I thought I'd compare the two, to see how they handle the simple name and address record structure used by Simon which is (in scala):
case class Person (name: String, address: Address, salary: Int)
case class Address (road: String, city: String, postcode: String)
// sample Person
val person = Person("Fred Bloggs", Address("Bayswater Road", "London", "W2 2UE"), 10000)
Lenses from Scalaz 7
A lens itself is a pretty simple affair, consisting only of a pair of functions, one for getting and another for setting the value that the lens describes, and doing this within the context of the container (i.e. the record). In scalaz, these are constructed with a good deal of boilerplate - there are two constructors available to you (lensg and lensu), one which curries the 'setting' function, and the other which does not:
val addressLens = Lens.lensg[Person, Address] (
a => value => a.copy(address = value),
_.address
)
// or
val nameLens = Lens.lensu[Person, String] (
(a, value) => a.copy(name = value),
_.name
)
Notice that each lens is defined in terms of two types - that of the value itself and that of its immediate container. Typically, you would then have to get hold of a lens for every atomic value you might wish to access:
val salaryLens = Lens.lensu[Person, Int] (
(a, value) => a.copy(salary = value),
_.salary
)
val roadLens = Lens.lensu[Address, String] (
(a, value) => a.copy(road = value),
_.road
)
val cityLens = Lens.lensu[Address, String] (
(a, value) => a.copy(city = value),
_.city
)
val postcodeLens = Lens.lensu[Address, String] (
(a, value) => a.copy(postcode = value),
_.postcode
)
This soon becomes tedious. However, the true usefulness of lenses comes to light when you compose them:
val personCityLens = addressLens andThen cityLens val personPostcodeLens = postcodeLens compose addressLensi.e. you can stay at the top of your record structure and reach down to the very bowels just by using one of these composite lenses. Scalaz, of course, offers you a shorthand hieroglyphic for these composition functions. So you could write them:
val personCityLens = addressLens >=> cityLens val personRoadLens = roadLens <=< addressLensNow you have your lenses defined, you can use them like this:
def get = salaryLens.get(person)
// res0: Int = 10000
def update = salaryLens.set(person, 20000)
// res1: Person = Person(Fred Bloggs,Address(Bayswater Road,London,W2 2UE),20000)
def transform = salaryLens.mod(_ + 500, person)
// res2: Person = Person(Fred Bloggs,Address(Bayswater Road,London,W2 2UE),10500)
def transitiveGet = personCityLens.get(person)
//res3: String = London
def transitiveSet:Person = {
val person1 = personCityLens.set(person, "Wakefield")
val person2 = personRoadLens.set(person1, "Eastmoor Road")
personPostcodeLens.set(person2, "WF1 3ST")
}
// res4: Person = Person(Fred Bloggs,Address(Eastmoor Road,Wakefield,WF1 3ST),10000)
With scalaz, you also get good integration with the other type classes you might need to use. So, for example, lenses can be lifted to behave monadically because the %= method applies the update and returns a State Monad.:
def updateViaMonadicState = {
val s = for {c <- personRoadLens %= {"124, " + _}} yield c
s(person)
}
//res13: (Person, String) = (Person(Fred Bloggs,Address(124, Bayswater Road,London,W2 2UE),10000),124, Bayswater Road)
Lenses from Shapeless
By contrast, Shapeless gets rid of all this boilerplate and allows for composition during the construction of the lenses themselves. It uses a positional notation to define the target field of each lens:val nameLens = Lens[Person] >> 0 val addressLens = Lens[Person] >> 1 val salaryLens = Lens[Person] >> 2 val roadLens = Lens[Person] >> 1 >> 0 val cityLens = Lens[Person] >> 1 >> 1 val postcodeLens = Lens[Person] >> 1 >> 2These can then be used in pretty much the same way as Scalaz 7's lenses. The main difference is that mod becomes modify and function application is curried:
def get = salaryLens.get(person)
// res0: Int = 10000
def update = salaryLens.set(person)(20000)
// res1: Person = Person(Fred Bloggs,Address(Bayswater Road,London,W2 2UE),20000)
def transform = salaryLens.modify(person)( _ + 500)
// res2: Person = Person(Fred Bloggs,Address(Bayswater Road,London,W2 2UE),10500)
def transitiveGet = cityLens.get(person)
// res3: String = London
def transitiveSet:Person = {
val person1 = cityLens.set(person)("Wakefield")
val person2 = roadLens.set(person1)("Eastmoor Road")
postcodeLens.set(person2)("WF1 3ST")
}
// res4: Person = Person(Fred Bloggs,Address(Eastmoor Road,Wakefield,WF1 3ST),10000)
As far as I can make out, Shapeless doesn't offer any monadic behaviour.
