Bow Optics入门：用Lens和Prism优雅操作不可变数据-尧图网络科技

Bow Optics入门：用Lens和Prism优雅操作不可变数据

【免费下载链接】bow🏹 Bow is a cross-platform library for Typed Functional Programming in Swift项目地址: https://gitcode.com/gh_mirrors/bow/bow

Bow是一个用于Swift的跨平台类型化函数式编程库，它提供了强大的Optics组件，帮助开发者以优雅的方式操作不可变数据。本文将带你快速掌握Lens和Prism这两种核心Optics工具，让你轻松应对复杂数据结构的修改挑战。

为什么需要Optics？

在函数式编程中，不可变数据是核心原则之一。但当面对嵌套较深的数据结构时，修改其中某个值就变得非常繁琐。例如，要更新一个用户对象中地址的城市字段，传统方式需要层层复制对象，既不高效也不美观。

Bow Optics提供了一种声明式的方式来访问和修改数据结构的特定部分，就像为数据结构安装了"光学镜片"，让你可以精准聚焦到需要操作的字段。

Lens：聚焦数据结构的特定字段

Lens是一种能够聚焦到数据结构特定字段的Optics工具，它本质上是一对函数：get（获取字段值）和set（设置字段值）。通过Lens，我们可以轻松访问和修改嵌套数据结构中的字段，而无需手动复制整个对象。

Lens的核心定义

在Bow Optics中，Lens的定义位于Sources/BowOptics/Lens.swift：

public typealias Lens<S, A> = PLens<S, S, A, A> public class PLens<S, T, A, B> { private let getFunc: (S) -> A private let setFunc: (S, B) -> T public init(get: @escaping (S) -> A, set: @escaping (S, B) -> T) { self.getFunc = get self.setFunc = set } public func get(_ s: S) -> A { ... } public func set(_ s: S, _ b: B) -> T { ... } // 其他方法... }

创建和使用Lens

假设我们有以下数据结构：

struct User { let name: String let address: Address } struct Address { let street: String let city: String }

我们可以创建一个Lens来聚焦到User的address字段：

let addressLens = Lens<User, Address>( get: { $0.address }, set: { user, newAddress in User(name: user.name, address: newAddress) } )

然后使用这个Lens来获取或修改用户的地址：

let user = User(name: "Alice", address: Address(street: "Main St", city: "New York")) let city = addressLens.get(user).city // 获取城市 let updatedUser = addressLens.set(user, Address(street: "Oak Ave", city: "Boston")) // 更新地址

Lens的组合

Lens最强大的特性之一是可组合性。我们可以将多个Lens组合起来，创建一个能够聚焦到深层嵌套字段的Lens：

let cityLens = addressLens + Lens<Address, String>( get: { $0.city }, set: { address, newCity in Address(street: address.street, city: newCity) } ) let updatedUser = cityLens.set(user, "Boston") // 直接更新城市

Prism：处理可选值和枚举类型

Prism是另一种重要的Optics工具，它适用于处理可选值和枚举类型。与Lens不同，Prism处理的是可能不存在的值或只能在特定条件下访问的值。

Prism的核心定义

Prism的定义位于Sources/BowOptics/Prism.swift：

public typealias Prism<S, A> = PPrism<S, S, A, A> public class PPrism<S, T, A, B> { private let getOrModifyFunc: (S) -> Either<T, A> private let reverseGetFunc: (B) -> T public init(getOrModify: @escaping (S) -> Either<T, A>, reverseGet: @escaping (B) -> T) { self.getOrModifyFunc = getOrModify self.reverseGetFunc = reverseGet } public func getOrModify(_ s: S) -> Either<T, A> { ... } public func reverseGet(_ b: B) -> T { ... } // 其他方法... }

Prism有两个核心函数：

getOrModify：尝试获取聚焦的值，如果失败则返回原始值
reverseGet：从聚焦的值构建原始类型

使用Prism处理可选值

假设我们有一个可选类型的变量，我们可以创建一个Prism来安全地访问它：

let optionalPrism = Prism<Int?, Int>( getOrModify: { optional in optional.map(Either.right) ?? .left(nil) }, reverseGet: { $0 } ) let someValue: Int? = 5 let noneValue: Int? = nil optionalPrism.getOption(someValue) // Option.some(5) optionalPrism.getOption(noneValue) // Option.none() optionalPrism.reverseGet(10) // 10 as Int?

使用Prism处理枚举类型

Prism特别适合处理枚举类型。例如，对于Result类型：

enum Result<Success, Failure: Error> { case success(Success) case failure(Failure) } let successPrism = Prism<Result<String, Error>, String>( getOrModify: { result in switch result { case .success(let value): return .right(value) case .failure(let error): return .left(.failure(error)) } }, reverseGet: { .success($0) } ) let successResult: Result<String, Error> = .success("Hello") let failureResult: Result<String, Error> = .failure(NSError(domain: "com.example", code: 1)) successPrism.getOption(successResult) // Option.some("Hello") successPrism.getOption(failureResult) // Option.none() successPrism.reverseGet("World") // .success("World")