The concept of functional Lens has become pretty popular in functional programming circles, and there are already good contributions for applying lenses to other, traditionally imperative/OO contexts. I’d like to offer a more in depth view on why lenses can be useful in Swift, and also talk about an associated concept called Prism. Let’s consider some practical problems and confront an idiomatic/imperative approach to the one based on lenses and prisms.

1. Lenses and Prisms in Swift
This work is licensed under the Creative Commons Attribution-NonCommercial-ShareAlike
3.0 Unported License. To view a copy of this license, visit http://creativecommons.org/licenses/by-nc-sa/
3.0/ or send a letter to Creative Commons, PO Box 1866, Mountain View, CA 94042, USA.

2. Functional getters and setters

3. Lenses and Prisms
→ encapsulate a relationship between a
data structure and its parts
→ simple to define
→ composition tools
→ build powerful abstractions

7. struct Lens<Whole,Part> {
let get: (Whole) -> Part
let set: (Part) -> (Whole) -> Whole
}
struct Prism<Whole,Part> {
let tryGet: (Whole) -> Part?
let inject: (Part) -> Whole
}

8. struct Lens<Whole,Part> {
let get: (Whole) -> Part
let set: (Part) -> (Whole) -> Whole
}
struct Prism<Whole,Part> {
let tryGet: (Whole) -> Part?
let inject: (Part) -> Whole
}

9. struct Lens<Whole,Part> {
let get: (Whole) -> Part
let set: (Part) -> (Whole) -> Whole
}
struct Prism<Whole,Part> {
let tryGet: (Whole) -> Part?
let inject: (Part) -> Whole
}

10. struct Lens<Whole,Part> {
let get: (Whole) -> Part
let set: (Part) -> (Whole) -> Whole
}
struct Prism<Whole,Part> {
let tryGet: (Whole) -> Part?
let inject: (Part) -> Whole
}

11. enum ViewState<T> {
case empty
case processing(String)
case failed(Error)
case completed(T)
}

12. enum ViewState<T> {
case empty
case processing(String)
case failed(Error)
case completed(T)
}

13. struct Lens<Whole,Part> {
let get: (Whole) -> Part
let set: (Part) -> (Whole) -> Whole
}
struct Prism<Whole,Part> {
let tryGet: (Whole) -> Part?
let inject: (Part) -> Whole
}

14. struct Lens<Whole,Part> {
let get: (Whole) -> Part
let set: (Part) -> (Whole) -> Whole
}
struct Prism<Whole,Part> {
let tryGet: (Whole) -> Part?
let inject: (Part) -> Whole
}

15. struct Lens<Whole,Part> {
let get: (Whole) -> Part
let set: (Part) -> (Whole) -> Whole
}
struct Prism<Whole,Part> {
let tryGet: (Whole) -> Part?
let inject: (Part) -> Whole
}

17. View

18. ViewModel

19. Functional
ViewModel

20. struct LoginPage {
var title: String
var credendials: CredentialBox
var buttonState: ViewState<Button>
}
struct CredentialBox {
var usernameField: TextField
var passwordField: TextField
}
struct TextField {
var text: String
var placeholder: String?
var secureText: Bool
}
struct Button {
var title: String
var enabled: Bool
}

21. struct LoginPage {
var title: String
var credendials: CredentialBox
var buttonState: ViewState<Button>
}
struct CredentialBox {
var usernameField: TextField
var passwordField: TextField
}
struct TextField {
var text: String
var placeholder: String?
var secureText: Bool
}
struct Button {
var title: String
var enabled: Bool
}

22. extension CredentialBox {
enum lens {
static var usernameField: Lens<CredentialBox,TextField> {
return Lens<CredentialBox,TextField>.init(
get: { whole in
whole.usernameField
},
set: { part in
{ whole in
var mutableWhole = whole
mutableWhole.usernameField = part
return mutableWhole
}
}
)
}
}
}

23. extension ViewState {
enum prism {
static var processing: Prism<ViewState,String> {
return .init(
tryGet: { whole in
guard case .processing(let message) = whole else {
return nil
}
return message
},
inject: { part in
.processing(part)
}
)
}
}
}

24. Manipulate the model
→ a previous model exists
→ set a greeting title
→ set a stored username
→ button initially not enabled

25. let initialState = (
title: "Welcome back!",
username: savedUsername,
buttonState: ViewState<Button>.completed(Button.init(
title: "Login",
enabled: false)))
var mutableNewModel = oldModel
mutableNewModel.title = initialState.title
mutableNewModel.credendials.usernameField.text = initialState.username
mutableNewModel.buttonState = initialState.buttonState

26. let initialState = (
title: "Welcome back!",
username: savedUsername,
buttonState: ViewState<Button>.completed(Button.init(
title: "Login",
enabled: false)))
var mutableNewModel = oldModel
mutableNewModel.title = initialState.title
mutableNewModel.credendials.usernameField.text = initialState.username
mutableNewModel.buttonState = initialState.buttonState

27. Lens<A,B> + Lens<B,C> = Lens<A,C>

28. extension Lens {
func compose<Subpart>(_ other: Lens<Part,Subpart>) -> Lens<Whole,Subpart> {
/// some code
}
}
extension Prism {
func compose<Subpart>(_ other: Prism<Part,Subpart>) -> Prism<Whole,Subpart> {
/// some code
}
}

29. let titleLens = LoginPage.lens.title
let usernameTextLens = LoginPage.lens.credentials
.compose(CredentialBox.lens.usernameField)
.compose(TextField.lens.text)
let buttonStateLens = LoginPage.lens.buttonState

30. let newModel = titleLens.set(initialState.title)
(usernameTextLens.set(initialState.username)
(buttonStateLens.set(initialState.buttonState)
(oldModel)))

31. Lens<A,B1> + Lens<A,B2> = Lens<A,(B1,B2)>

32. extension Lens {
static func zip<Part1,Part2>(
_ a: Lens<Whole,Part1>,
_ b: Lens<Whole,Part2>)
-> Lens<Whole,(Part1,Part2)>
where Part == (Part1,Part2)
{
/// some code
}
}
extension Prism {
static func zip<Part1,Part2>(
_ a: Prism<Whole,Part1>,
_ b: Prism<Whole,Part2>)
-> Prism<Whole,Either<Part1,Part2>>
where Part == Either<Part1,Part2>
{
/// some code
}
}

33. let initialStateLens = Lens.zip(
titleLens,
usernameTextLens,
buttonStateLens)
let newModel = initialStateLens.set(initialState)(oldModel)

34. What
about
prisms?

35. func advanceProcessingMessage(_ previous: String) -> String {
switch previous {
case "Please wait":
return "Almost there"
case "Almost there":
return "ALMOST THERE"
default:
return previous + "!"
}
}

36. extension Lens {
func modify(_ transform: (Part) -> Part) -> (Whole) -> Whole {
/// some code
}
}
extension Prism {
func tryModify(_ transform: (Part) -> Part) -> (Whole) -> Whole {
/// some code
}
}

37. /// Prism<ViewState<Button>,String>
let processingPrism = ViewState<Button>.prism.processing
let modifyLoginPage: ((ViewState<Button>) -> ViewState<Button>)
-> (LoginPage) -> LoginPage
modifyLoginPage = buttonStateLens.modify
let modifyProcessingMessage: ((String) -> String)
-> (ViewState<Button>) -> ViewState<Button>
modifyProcessingMessage = processingPrism.tryModify

38. /// Prism<ViewState<Button>,String>
let processingPrism = ViewState<Button>.prism.processing
let modifyLoginPage: ((ViewState<Button>) -> ViewState<Button>)
-> (LoginPage) -> LoginPage
modifyLoginPage = buttonStateLens.modify
let modifyProcessingMessage: ((String) -> String)
-> (ViewState<Button>) -> ViewState<Button>
modifyProcessingMessage = processingPrism.tryModify

39. (A -> B) + (B -> C) = (A -> C)

40. infix operator >>>
func >>> <A,B,C> (
_ left: @escaping (A) -> B,
_ right: @escaping (B) -> C)
-> (A) -> C
{
return { right(left($0)) }
}

41. let onProcessing: ((String) -> String) -> (LoginPage) -> LoginPage
onProcessing = modifyProcessingMessage >>> modifyLoginPage
let newModel = onProcessing(advanceProcessingMessage)(oldModel)

42. Let's recap
→ separated logic for accessing and mutating data;
→ defined simple, composable atomic objects;
→ built more complex objects just by combination;
→ transformed data with multiple, independent
pieces;
→ types are the only interface;
→ nothing will break if types don't change;
→ are we sure?

43. Buggy
lenses?

44. LAWS

45. Laws
→ required when building large systems
from small pieces
→ we need to trust the pieces
→ they are implicit in tests
→ let's define them explicitly for Lenses
and Prisms

46. Laws: Lens
→ getSet: the whole stays the same
→ setGet: the part stays the same
→ setSet: set is idempotent

47. Laws: Prisms
→ tryGetInject
→ injectTryGet

48. struct LensLaw {
static func setGet<Whole, Part>(
lens: Lens<Whole,Part>,
whole: Whole,
part: Part)
-> Bool where Part: Equatable
{
return lens.get(lens.set(part)(whole)) == part
}
}

49. Do we need to test ALL lenses and
prisms?
→ trivial lenses have always the same
structure;
→ if written by hand, tests can be useful;
→ lots of boilerplate;
→ a perfect fit for code generation;
→ Sourcery

50. Deriving
Lens from
KeyPath

51. extension WritableKeyPath {
var lens: Lens<Root,Value> {
return Lens<Root,Value>.init(
get: { root in
root[keyPath: self]
},
set: { value in
{ root in
var mutableRoot = root
mutableRoot[keyPath: self] = value
return mutableRoot
}
}
)
}
}
let passwordLens = (LoginPage.credentials.passwordField.text).lens

52. Non-trivial lenses and prisms
→ outputs of combinators;
→ particular data structures.

53. extension Dictionary {
static func lens(at key: Key) -> Lens<Dictionary,Value?> {
return Lens<Dictionary,Value?>(
get: { dict in
dict[key]
},
set: { value in
{ dict in
var mutableDict = dict
mutableDict[key] = value
return mutableDict
}
}
)
}
}

54. extension Dictionary {
static func lens(at key: Key) -> Lens<Dictionary,Value?> {
return Lens<Dictionary,Value?>(
get: { dict in
dict[key]
},
set: { value in
{ dict in
var mutableDict = dict
mutableDict[key] = value
return mutableDict
}
}
)
}
}

55. Lens<A,B?> + Lens<B,C> = ?

56. extension Optional {
static var prism: Prism<Optional,Wrapped> {
return Prism<Optional,Wrapped>.init(
tryGet: { $0 },
inject: Optional.some
)
}
}

57. Lens<A,B?> + Prism<B?,B> + Lens<B,C> = ?

58. struct Affine<Whole,Part> {
let tryGet: (Whole) -> Part?
let trySet: (Part) -> (Whole) -> Whole?
}
/// laws are similar to lens'
/// es. Affine to an index of an Array

59. Lens<A,B> + Prism<B,C> = Affine<A,C>

60. Lens<A,B> -> Affine<A,B>
Prism<A,B> -> Affine<A,B>

61. Lens<A,B?> + Prism<B?,B> +
Lens<B,C> =
Affine<A,B> + Lens<B,C> =
Affine<A,B> + Affine<B,C> =
Affine<A,C>

62. FunctionalKit library
https://github.com/facile-it/FunctionalKit
→ Lens, Prism, Affine definitions
→ some combinators
→ Law functions

63. Thanks

64. Links and Contacts
→ @_logicist
→ https://github.com/broomburgo/
Lenses-and-Prisms-in-Swift
→ https://github.com/facile-it/
FunctionalKit
→ Brandon Williams's original talk on
lenses: https://youtu.be/ofjehH9f-CU