Focus

Focus is an Optics library for Swift (where Optics includes Lens, Prisms, and Isos) that is inspired by Haskell's Lens library.

Introduction

Focus exports a number of primitives that make it easy to establish relations between types. Practically, a relation can be thought of as a particular way of viewing and modifying a structure. The most famous of these is a Lens or Functional Reference. While there are an abundance of representations of a Lens (see [van Laarhoven 09], [Kmett et al. 12], [Eidhof et al. 09], we have chosen a data-lens-like implementation using the Indexed Store Comonad. If all of that makes no sense, don't worry! We have hidden all of this behind a simple interface.

Programming With Lenses

The easiest way to explain a lens is with a pair of functions

func get(structure : S) -> A
func set(pair : (self : S, newValue : A)) -> S

This should look quite familiar to you! After all, Swift includes syntax for this very pattern

final class Foo {
	var bar : Qux {
		get { //.. }
		set(newValue) { //.. }
	}
}

So what a lens actually lets you do is decouple the ability to focus on particular bits and pieces of your data types. Moreover, lenses, like properties, compose freely with other compatible lenses but with normal function composition (denoted •) instead of the usual dot-notation. What sets Lenses apart from straight properties is every part of the process is immutable. A lens performs replacement of the entire structure, a property performs replacement of a mutable value within that structure.

All of these properties, flexibility immutability, and composability, come together to enable a powerful set of operations that allow the programmer to view a structure and its parts at any depth and any angle, not simply those provided by properties.

Practical Lenses

For example, say we have this set of structures for working with a flight tracking app:

import Foundation
import Focus

enum Status {
	case Early
	case OnTime
	case Late
}

struct Plane {
	let model : String
	let freeSeats : UInt
	let takenSeats : UInt
	let status : Status
	var totalSeats : UInt {
		return self.freeSeats + self.takenSeats
	}
}

struct Gate {
	let number : UInt
	let letter : Character
}

struct BoardingPass {
	let plane : Plane
	let gate : Gate
	let departureDate : NSDate
	let arrivalDate : NSDate
}

Starting with a BoardingPass, getting our flight status is trivial

let plane = Plane(model: "SpaceX Raptor", freeSeats: 4, takenSeats: 0, status: .OnTime)
let gate = Gate(number: 1, letter: "A")
let pass = BoardingPass(plane: plane
					, gate: gate
					, departureDate: NSDate.distantFuture()
					, arrivalDate: NSDate.distantFuture())
let status = pass.plane.status

However, in order to update the status on the boarding pass without lenses, we'd have to go through this rigamarole every time:

let oldPass = BoardingPass(/* */)
// Apparently, we're actually flying Allegiant
let newFlight = Plane(model: oldPass.plane.model
					, freeSeats: oldPass.plane.freeSeats
					, takenSeats: oldPass.plane.takenSeats
					, status: .Late)
let newPass = BoardingPass(plane: newFlight
						, gate: oldPass.gate
						, departureDate: oldPass.departureDate
						, arrivalDate: oldPass.arrivalDate)

After defining a few lenses, this is what we can do instead:

// The composite of two lenses is itself a lens
let newPass = (BoardingPass._plane • Plane._status).set(oldPass, .Late)

Here's the definition of those lenses:

extension BoardingPass {
	static var _plane : SimpleLens<BoardingPass, Plane> {
		return SimpleLens(get: {
			return $0.plane
		}, set: { (oldPass, newP) in
			return BoardingPass(plane: newP
							, gate: oldPass.gate
							, departureDate: oldPass.departureDate
							, arrivalDate: oldPass.arrivalDate)
		})
	}
}

extension Plane {
	static var _status : SimpleLens<Plane, Status> {
		return SimpleLens(get: {
			return $0.status
		}, set: { (oldP, newS) in
			return Plane( model: oldP.model
						, freeSeats: oldP.freeSeats
						, takenSeats: oldP.takenSeats
						, status: newS)
		})
	}
}

We've only scratched the surface of the power of Lenses, and we haven't even touched the other members of the family of optics exported by Focus. For more on the Lens Family, check out the additional sources below and the implementation files for each family member.

Further Reading

• The Lens Library's website.
• Aditya Bhargava's marvelous illustrated guide to lenses.
• Haskell for All's Gabriel Gonzalez explains how to program imperatively using lenses
• Functional Programming with Bananas, Lenses, Envelopes and Barbed Wire.
• Edward Kmett's talk on Lenses, Folds, and Traversals.
• In fact, pretty much everything Edward Kmett has talked about.

System Requirements

Focus supports OS X 10.9+ and iOS 8.0+.

License

Focus is released under the MIT license.