Lenses and prisms in Swift

Understanding optics

Optics is a sample borrowed from Haskell, that lets you zoom down into objects. In different phrases, you possibly can set or get a property of an object in a practical means. By practical I imply you possibly can set a property with out inflicting mutation, so as a substitute of altering the unique object, a brand new one can be created with the up to date property. Belief me it isn’t that difficult as it’d sounds. 😅

We’ll want only a little bit of Swift code to know every part.

struct Tackle {
    let avenue: String
    let metropolis: String
}

struct Firm {
    let identify: String
    let tackle: Tackle
}

struct Individual {
    let identify: String
    let firm: Firm
}

As you possibly can see it’s potential to construct up a hierarchy utilizing these structs. An individual can have an organization and the corporate has an tackle, for instance:

let oneInfiniteLoop = Tackle(avenue: "One Infinite Loop", metropolis: "Cupertino")
let appleInc = Firm(identify: "Apple Inc.", tackle: oneInfiniteLoop)
let steveJobs = Individual(identify: "Steve Jobs", firm: appleInc)

Now lets say that the road identify of the tackle adjustments, how can we alter this one subject and propagate the property change for the whole construction? 🤔

struct Tackle {
    var avenue: String
    let metropolis: String
}

struct Firm {
    let identify: String
    var tackle: Tackle
}

struct Individual {
    let identify: String
    var firm: Firm
}

var oneInfiniteLoop = Tackle(avenue: "One Infinite Loop", metropolis: "Cupertino")
var appleInc = Firm(identify: "Apple Inc.", tackle: oneInfiniteLoop)
var steveJobs = Individual(identify: "Steve Jobs", firm: appleInc)

oneInfiniteLoop.avenue = "Apple Park Approach"
appleInc.tackle = oneInfiniteLoop
steveJobs.firm = appleInc

print(steveJobs) 

With a purpose to replace the road property we needed to do numerous work, first we needed to change a number of the properties to variables, and we additionally needed to manually replace all of the references, since structs aren’t reference sorts, however worth sorts, therefore copies are getting used throughout.

This appears actually unhealthy, we have additionally induced numerous mutation and now others can even change these variable properties, which we do not mandatory need. Is there a greater means? Properly…

let newSteveJobs = Individual(identify: steveJobs.identify,
                      firm: Firm(identify: appleInc.identify,
                                       tackle: Tackle(avenue: "Apple Park Approach",
                                                        metropolis: oneInfiniteLoop.metropolis)))

Okay, that is ridiculous, can we truly do one thing higher? 🙄

Lenses

We will use a lens to zoom on a property and use that lens to assemble complicated sorts. A lens is a worth representing maps between a fancy kind and certainly one of its property.

Let’s maintain it easy and outline a Lens struct that may remodel an entire object to a partial worth utilizing a getter, and set the partial worth on the whole object utilizing a setter, then return a brand new “entire object”. That is how the lens definition appears like in Swift.

struct Lens<Complete, Half> {
    let get: (Complete) -> Half
    let set: (Half, Complete) -> Complete
}

Now we are able to create a lens that zooms on the road property of an tackle and assemble a brand new tackle utilizing an current one.

let oneInfiniteLoop = Tackle(avenue: "One Infinite Loop", metropolis: "Cupertino")
let appleInc = Firm(identify: "Apple Inc.", tackle: oneInfiniteLoop)
let steveJobs = Individual(identify: "Steve Jobs", firm: appleInc)

let addressStreetLens = Lens<Tackle, String>(get: { $0.avenue },
                                              set: { Tackle(avenue: $0, metropolis: $1.metropolis) })


let newSteveJobs = Individual(identify: steveJobs.identify,
                          firm: Firm(identify: appleInc.identify,
                                           tackle: addressStreetLens.set("Apple Park Approach", oneInfiniteLoop)))

Let’s attempt to construct lenses for the opposite properties as effectively.

let oneInfiniteLoop = Tackle(avenue: "One Infinite Loop", metropolis: "Cupertino")
let appleInc = Firm(identify: "Apple Inc.", tackle: oneInfiniteLoop)
let steveJobs = Individual(identify: "Steve Jobs", firm: appleInc)

let addressStreetLens = Lens<Tackle, String>(get: { $0.avenue },
                                              set: { Tackle(avenue: $0, metropolis: $1.metropolis) })

let companyAddressLens = Lens<Firm, Tackle>(get: { $0.tackle },
                                                set: { Firm(identify: $1.identify, tackle: $0) })

let personCompanyLens = Lens<Individual, Firm>(get: { $0.firm },
                                              set: { Individual(identify: $1.identify, firm: $0) })

let newAddress = addressStreetLens.set("Apple Park Approach", oneInfiniteLoop)
let newCompany = companyAddressLens.set(newAddress, appleInc)
let newPerson = personCompanyLens.set(newCompany, steveJobs)

print(newPerson)

This would possibly appears a bit unusual at first sight, however we’re simply scratching the floor right here. It’s potential to compose lenses and create a transition from an object to a different property contained in the hierarchy.

struct Lens<Complete, Half> {
    let get: (Complete) -> Half
    let set: (Half, Complete) -> Complete
}

extension Lens {
    func transition<NewPart>(_ to: Lens<Half, NewPart>) -> Lens<Complete, NewPart> {
        .init(get: { to.get(get($0)) },
              set: { set(to.set($0, get($1)), $1) })
    }

}



let personStreetLens = personCompanyLens.transition(companyAddressLens)
                                        .transition(addressStreetLens)


let newPerson = personStreetLens.set("Apple Park Approach", steveJobs)

print(newPerson)

So in our case we are able to give you a transition technique and create a lens between the particular person and the road property, this can permit us to straight modify the road utilizing this newly created lens.

Oh, by the way in which, we are able to additionally lengthen the unique structs to supply these lenses by default. 👍

extension Tackle {
    struct Lenses {
        static var avenue: Lens<Tackle, String> {
            .init(get: { $0.avenue },
                  set: { Tackle(avenue: $0, metropolis: $1.metropolis) })
        }
    }
}

extension Firm {

    struct Lenses {
        static var tackle: Lens<Firm, Tackle> {
            .init(get: { $0.tackle },
                  set: { Firm(identify: $1.identify, tackle: $0) })
        }
    }
}

extension Individual {

    struct Lenses {
        static var firm: Lens<Individual, Firm> {
            .init(get: { $0.firm },
                  set: { Individual(identify: $1.identify, firm: $0) })
        }
        
        static var companyAddressStreet: Lens<Individual, String> {
            Individual.Lenses.firm
                .transition(Firm.Lenses.tackle)
                .transition(Tackle.Lenses.avenue)
        }
    }

}

let oneInfiniteLoop = Tackle(avenue: "One Infinite Loop", metropolis: "Cupertino")
let appleInc = Firm(identify: "Apple Inc.", tackle: oneInfiniteLoop)
let steveJobs = Individual(identify: "Steve Jobs", firm: appleInc)

let newPerson = Individual.Lenses.companyAddressStreet.set("Apple Park Approach", steveJobs)

print(newPerson)

On the decision web site we have been in a position to make use of one single line to replace the road property of an immutable construction, in fact we’re creating a brand new copy of the whole object, however that is good since we wished to keep away from mutations. In fact we’ve to create numerous lenses to make this magic occur beneath the hood, however generally it’s definitely worth the effort. ☺️

Prisms

Now that we all know the best way to set properties of a struct hierarchy utilizing a lens, let me present you another knowledge kind that we are able to use to change enum values. Prisms are identical to lenses, however they work with sum sorts. Lengthy story brief, enums are sum sorts, structs are product sorts, and the principle distinction is what number of distinctive values are you able to characterize with them.

struct ProductExample {
    let a: Bool 
    let b: Int8 
}



enum SumExample {
    case a(Bool) 
    case b(Int8) 
}

One other distinction is {that a} prism getter can return a 0 worth and the setter can “fail”, this implies if it’s not potential to set the worth of the property it’s going to return the unique knowledge worth as a substitute.

struct Prism<Complete, Half> {
    let tryGet: (Complete) -> Half?
    let inject: (Half) -> Complete
}

That is how we are able to implement a prism, we name the getter tryGet, because it returns an non-obligatory worth, the setter known as inject as a result of we attempt to inject a brand new partial worth and return the entire if potential. Let me present you an instance so it will make extra sense.

enum State {
    case loading
    case prepared(String)
}

extension State {

    enum Prisms {
        static var loading: Prism<State, Void> {
            .init(tryGet: {
                guard case .loading = $0 else {
                    return nil
                }
                return ()
            },
            inject: { .loading })
        }
        
        static var prepared: Prism<State, String> {
            .init(tryGet: {
                guard case let .prepared(message) = $0 else {
                    return nil
                }
                return message
            },
            inject: { .prepared($0) })
        }
    }
}

we have created a easy State enum, plus we have prolonged it and added a brand new Prism namespace as an enum with two static properties. ExactlyOne static prism for each case that we’ve within the authentic State enum. We will use these prisms to examine if a given state has the appropriate worth or assemble a brand new state utilizing the inject technique.

let loadingState = State.loading
let readyState = State.prepared("I am prepared.")


let newLoadingState = State.Prisms.loading.inject(())

let newReadyState = State.Prisms.prepared.inject("Hurray!")



let nilMessage = State.Prisms.prepared.tryGet(loadingState)
print(nilMessage)


let message = State.Prisms.prepared.tryGet(readyState)
print(message)

The syntax looks as if a bit unusual on the first sight, however belief me Prisms could be very helpful. You may also apply transformations on prisms, however that is a extra superior matter for an additional day.

Anyway, this time I would prefer to cease right here, since optics are fairly an enormous matter and I merely cannot cowl every part in a single article. Hopefully this little article will provide help to to know lenses and prisms only a bit higher utilizing the Swift programming language. 🙂