Is there any reason vars shouldn't be used in data model structs? The struct will still be immutable in the sense that there is no shared mutable state, and it would permit lenses to be expressed without having the call the struct's initializer for each individual lens.

This pull request introduces the IsoType, LensType, PrismType, and OpticFamilyType protocols, and moves a lot of functionality to extensions on them rather than methods on the underlying structs.

This shouldn’t affect any current usages of the library, other than no longer requiring asLens or asPrism calls (thus, those functions have been removed). However, it will allow for much easier expansion in the future, as well as greater fluidity of the interface when it comes to the “multiple inheritance” of various optic types.

The other Swift Lens framework, Monocle, has taken to a data-accessor-esque implementation of Lenses, and I think there's something to the idea of including a record-accessor structure with Focus. Especially since Swift doesn't allow polymorphic type aliases, and Monomorphic lenses are just easier to reason about for the general Swift programmer.

Let me know if there is a different approach you had in mind. I could also use some feedback on making the documentation summary more complete and clear.

I am thoroughly disappointed with the way this turned out. I need to think a bit more about how to generate inverse functions with SwiftCheck before this gets merged.

Without this setting, any application extensions will warn on linking with this framework and can result in app store rejection. Adding the setting only prevents use of APIs that are unavailable in the context of an extension (such as UIApplication.sharedApplication() on iOS).

The majority of changes in this pull request have to do with the README. It was always bothering me that we just kept around the same old thing from Swiftz and didn't bother to change it. I intend this as a work in progress, so additions, removals, changes, everything, are open.

Adding an issue for this before submitting a PR since I'm not sure if disabling was intentional or not. If it was intentional, was there a reason for disabling it? It seems like being in the Xcode project settings it would not impact SPM builds.

Fetching https://github.com/typelift/Focus error: the package https://github.com/typelift/Focus @ 0.4.0 contains revisioned dependencies: https://github.com/typelift/SwiftCheck.git @ master https://github.com/typelift/Operadics.git @ master

import Swiftz 
import Focus

func fanin<A, B, C>(_ l: @escaping (A) -> C, _ r: @escaping (B) -> C) -> Function<Either<A, B>, C> {
    return Function.arr(l) ||| Function.arr(r)
}

The above fails to compile and there doesn't seem to be a way to specify which library you want the operator to come from since Swiftz.||| fails to compile.

***: error: ambiguous operator declarations found for operator return Function.arr(l) ||| Function.arr(r) ^ :0: note: found this matching operator declaration :0: note: found this matching operator declaration ***: error: operator is not a known binary operator return Function.arr(l) ||| Function.arr(r)

Is there no way to lens through an optional? I've tried with Party.lpartyCaterer() • User.userName and Party.lpartyCaterer() • _Some • User.userName, to no avail.

// A party has a host, an optional caterer and an array of guests
class Party {
    var host : User
    var caterer : User?
    var guests : [User]

    init(h : User, c : User? = nil, g : [User] = []) {
        host = h
        caterer = c
        guests = g
    }

    class func lpartyHost() -> Lens<Party, Party, User, User> {
        let getter = { (party : Party) -> User in party.host }
        let setter = { (party : Party, host : User) -> Party in Party(h: host, c: party.caterer, g: party.guests) }
        return Lens(get: getter, set: setter)
    }

    class func lpartyCaterer() -> Lens<Party, Party, User?, User?> {
        let getter = { (party : Party) -> User? in party.caterer }
        let setter = { (party : Party, caterer : User?) -> Party in Party(h: party.host, c: caterer, g: party.guests) }
        return Lens(get: getter, set: setter)
    }

    class func lpartyGuests() -> Lens<Party, Party, [User], [User]> {
        let getter = { (party : Party) -> [User] in party.guests }
        let setter = { (party : Party, guests : [User]) -> Party in Party(h: party.host, c: party.caterer, g: guests) }
        return Lens(get: getter, set: setter)
    }
}

class PartySpec : XCTestCase {
    func testLens() {
        let party = Party(h: User("max", 1, [], "one"))
        let hostnameLens = Party.lpartyHost() • User.userName

        XCTAssert(hostnameLens.get(party) == "max")

        let updatedParty: Party = (Party.lpartyHost() • User.userName).set(party, "Max")
        XCTAssert(hostnameLens.get(updatedParty) == "Max")

        let catererLens = Party.lpartyCaterer() • User.userName

        let cateredParty: Party = (Party.lpartyCaterer() • User.userName).set(party, "Marc")
        XCTAssert(catererLens.get(updatedParty) == "Marc")

    }
}