# fp-ts 代数数据类型和类型类此技能涵盖代数数据类型 (ADT) 和 fp-ts 中的类型类，用于在 TypeScript 中进行稳健的域建模。 ## 核心概念 ### 什么是代数数据类型？代数数据类型 (ADT) 是通过组合其他类型形成的复合类型。有两种基本类型： * **产品类型** ：使用 AND（元组、记录）组合类型 - “用户有姓名和电子邮件” * **Sum Types** ：使用 OR（可区分联合）组合类型 - “结果要么成功，要么失败” ### 什么是类型类？类型类定义了可以为不同类型实现的行为。在 fp-ts 中，它们表示为具有特定类型实例的接口： * **Eq** : 相等比较 * **Ord** : 订购/比较 * **半群** ：组合相同类型的两个值 * **Monoid** ：具有单位元的半群 ## 产品类型产品类型表示同时包含其所有组成部分的值。 ### 元组元组是具有类型化位置的固定长度数组。从'fp-ts/function'导入{管道} 从 'fp-ts/Tuple' 导入 * as T // 基本元组类型类型 Point2D = 只读 [数字，数字] 类型 NamedValue = 只读 [字符串，数字] 常量点：Point2D = [10, 20] const 项：NamedValue = ['分数', 100] // 访问元组元素 const [x, y] = 点 const [标签，值] = 项目 // 来自 fp-ts 的元组操作 const 首先 = T.fst(point) // 10 const 第二 = T.snd(point) // 20 // 映射到第一个元素 const doubled = T.mapFst((n: number) => n * 2)(point) // [20, 20] // 映射到第二个元素 const 递增 = T.mapSnd((n: number) => n + 1)(point) // [10, 21] // Bimap：变换两个元素常量变换 = T.bimap( (n: 数字) => n.toString(), （n：数字）=> n * 2 )(点) // ['20', 20] ### 记录（对象类型）记录是 TypeScript 中最常见的产品类型。 // 作为产品类型的领域模型界面用户{ 只读 ID：字符串只读电子邮件：字符串只读名称：字符串只读创建时间：日期 } // 所有字段都必须存在 - 这就是它成为“产品”的原因常量用户：用户= { id: '123', 电子邮件：'john@example.com'，名称：“约翰·多伊”，创建时间：新日期() } // 嵌套产品类型接口顺序{ 只读 ID：字符串只读客户：用户只读项目：ReadonlyArray 只读送货：送货地址只读计费：BillingInfo } 接口订单项{ 只读产品ID：字符串只读数量：数量只读单位价格：数量 } 接口运输地址{ 只读街道：字符串只读城市：字符串只读邮政编码：字符串只读国家/地区：字符串 } 接口帐单信息{ 只读方法：PaymentMethod 只读cardLast4？：字符串 } ### 何时使用产品类型在以下情况下使用产品类型： * 实体要求所有数据都有效 * 数据自然属于在一起 * 您正在对数据库实体或 API 负载进行建模 * 组件总是一起出现 // 好：有效配置需要所有字段接口数据库配置{ 只读主机：字符串只读端口：号码只读数据库：字符串只读用户名：字符串只读密码：字符串 } // 好：坐标总是需要 x 和 y 界面坐标{ 只读 x: 数字只读 y：数字 } // 好：钱需要数量和货币接口钱{ 只读金额：数量只读货币：字符串 } ## 总和类型（可区分联合） Sum 类型表示的值可以是多个变体之一。 ### 基本的受歧视工会 // 付款可以是以下类型之一输入付款方式= | { readonly _tag: '信用卡';只读卡号：字符串；只读到期：字符串} | { readonly_tag: '贝宝';只读电子邮件：字符串} | { readonly _tag: '银行转账';只读帐号：字符串；只读路由编号：字符串} | { readonly _tag: '加密货币';只读钱包地址：字符串；只读网络：字符串} // 创造价值常量信用卡：付款方式 = { _tag: '信用卡', 卡号: '4111111111111111', 到期时间：'12/25' } const paypal: 付款方式 = { _tag: '贝宝', 电子邮件：'user@example.com' } ### 模式匹配与折叠/匹配从'fp-ts/function'导入{管道} // 定义一个折叠函数以进行详尽的模式匹配 const FoldPaymentMethod = (处理程序：{ 信用卡：（卡号：字符串，到期日：字符串）=> R 贝宝：（电子邮件：字符串）=> R 银行转账：（帐号：字符串，路由编号：字符串）=> R 加密货币：（钱包地址：字符串，网络：字符串）=> R }) => (付款: PaymentMethod): R => { 开关（付款._tag）{ 案例“信用卡”：返回 handlers.CreditCard( payment.cardNumber, payment.expiry) 案例“贝宝”：返回处理程序.PayPal(付款.电子邮件) 案例“银行转账”：返回 handlers.BankTransfer( payment.accountNumber, payment.routingNumber) 案例“加密货币”：返回 handlers.Crypto( payment.walletAddress, payment.network) } } // 用法 const getPaymentLabel = FoldPaymentMethod({ 信用卡：(num, _) => `以 ${num.slice(-4)} 结尾的卡`, 贝宝：（电子邮件）=>`贝宝：${电子邮件}`，银行转账：(acc, _) => `银行：${acc.slice(-4)}`, 加密货币: (钱包, 网络) => `${network}: ${wallet.slice(0, 8)}...` }) const label = getPaymentLabel(creditCard) // “以 1111 结尾的卡” ### Sum 类型的智能构造函数 // 定义联合类型 RemoteData = | { readonly _tag: 'NotAsked' } | { readonly _tag: '正在加载' } | { readonly _tag: '失败';只读错误：E } | { readonly _tag: '成功';只读数据：A } // 智能构造函数 const notAsked: RemoteData = { _tag: 'NotAsked' } const loading: RemoteData = { _tag: '正在加载' } const failure = (error: E): RemoteData => ({ _tag: '失败', error }) const success = (data: A): RemoteData => ({ _tag: '成功', data }) // 类型保护 const isNotAsked = (rd: RemoteData): rd is { _tag: 'NotAsked' } => rd._tag === '未询问' const isLoading = (rd: RemoteData): rd is { _tag: '正在加载' } => rd._tag === '正在加载' const isFailure = (rd: RemoteData): rd is { _tag: '失败';错误：E } => rd._tag === '失败' const isSuccess = (rd: RemoteData): rd is { _tag: '成功';数据：A} => rd._tag === '成功' // 折叠以进行详尽匹配 const Fold = (处理程序: { 未询问：() => R 加载：() => R 失败：（错误：E）=> R 成功：（数据：A）=> R }) => (rd: RemoteData): R => { 开关（rd._tag）{ case 'NotAsked': 返回 handlers.NotAsked() case 'Loading': 返回 handlers.Loading() case 'Failure': 返回 handlers.Failure(rd.error) case 'Success': 返回 handlers.Success(rd.data) } } // 在 React 中的用法 const UserProfile = ({ data }: { data: RemoteData<错误, 用户> }) => 管道（数据，折叠（{ 未询问：() => <按钮>加载配置文件，加载：() => , 失败：(err) => , 成功：（用户）=> }) ） ### 何时使用 Sum 类型在以下情况下使用求和类型： * 一个值可以处于不同的状态 * 不同的变体有不同的数据形状 * 您需要彻底处理所有案件 * 状态机或工作流程建模 // 好：订单状态是互斥的输入订单状态= | { readonly _tag: '待处理' } | { readonly _tag: '已确认';只读确认时间：日期 } | { readonly _tag: '已发货';只读跟踪编号：字符串；只读发货时间：日期 } | { readonly _tag: '已交付';只读交付时间：日期 } | { readonly _tag: '已取消';只读原因：字符串；只读取消于：日期} // 好：API 响应状态类型 ApiResponse = | { readonly _tag: '空闲' } | { readonly _tag: '正在加载' } | { readonly _tag: '错误';只读消息：字符串；只读代码：数字} | { readonly _tag: '成功';只读数据：T } // Good: 表单字段验证状态类型 FieldState = | { readonly _tag: '原始';只读值：T } | { readonly _tag: '有效';只读值：T } | { readonly _tag: '无效';只读值：T；只读错误：ReadonlyArray } ## 半群半群定义如何组合两个相同类型的值。它必须满足结合律：`combine(combine(a, b), c) ===combine(a,combine(b, c))` ### 基本半群用法从 'fp-ts/Semigroup' 导入 * as S 从 'fp-ts/number' 导入 * as N 从 'fp-ts/string' 导入 * as Str 从'fp-ts/function'导入{管道} // 内置半群 const sumResult = S.concatAll(N.SemigroupSum)(0)([1, 2, 3, 4]) // 10 const ProductResult = S.concatAll(N.SemigroupProduct)(1)([1, 2, 3, 4]) // 24 const stringResult = S.concatAll(Str.Semigroup)('')(['Hello', ' ', 'World']) // 'Hello World' // 组合两个值 const sum = N.SemigroupSum.concat(5, 3) // 8 常量产品 = N.SemigroupProduct.concat(5, 3) // 15 ### 自定义半群实例从 'fp-ts/Semigroup' 导入 * as S 从'fp-ts/function'导入{管道} // 取第一个值的半群 const 首先 = (): S.Semigroup => ({ 连接： (x, _) => x }) // 取最后一个值的半群 const 最后 = (): S.Semigroup => ({ 连接：(_, y) => y }) // 求最大值的半群 const max: S.Semigroup = { 连接： (x, y) => Math.max(x, y) } // 最小值半群 const min: S.Semigroup = { 连接： (x, y) => Math.min(x, y) } ### 实际示例：合并配置从 'fp-ts/Semigroup' 导入 * as S 从'fp-ts/function'导入{管道} 接口服务器配置{ 只读主机：字符串只读端口：号码只读超时：数字只读重试次数：次数只读功能：ReadonlyArray } // 合并配置的半组（稍后的值覆盖） const ServerConfigSemigroup: S.Semigroup = S.struct({ host: S.last(), // 最后一个值获胜 port: S.last(), // 最后一个值获胜 timeout: S.max(N.Ord), // 取最大超时时间 retries: S.max(N.Ord), // 取最大重试次数 features: { // 连接数组连接： (x, y) => [...new Set([...x, ...y])] } }) // 默认配置 const 默认配置：服务器配置 = { 主机：'本地主机'，端口：3000，超时：5000，重试次数：3，特点：['记录'] } // 特定于环境的覆盖 const prodOverrides: ServerConfig = { 主机：'api.example.com'，端口：443，超时：10000，重试次数：5次，功能：['监控'、'缓存'] } // 合并配置 const FinalConfig = ServerConfigSemigroup.concat(defaultConfig, prodOverrides) // { // 主机: 'api.example.com', // 端口：443， // 超时: 10000, // 重试次数：5, // 功能: ['日志记录', '监控', '缓存'] // } // 合并多个配置 const configs = [defaultConfig、devOverrides、envOverrides、cliOverrides] const mergedConfig = S.concatAll(ServerConfigSemigroup)(defaultConfig)(configs) ### 可选值的半群从 'fp-ts/Semigroup' 导入 * as S 从 'fp-ts/Option' 导入 * as O // 偏好某些值的选项的半群 const getOptionSemigroup = (S: S.Semigroup ): S.Semigroup> => O.getMonoid(S) // 或者使用内置的从 'fp-ts/Apply' 导入 { getApplySemigroup } 从 'fp-ts/Option' 导入 { 应用性 } const optionStringSemigroup = getApplySemigroup(Applicative)(Str.Semigroup) // 示例：合并可选配置接口部分配置{ 只读主机？：字符串只读端口？：号码 } const mergePartialConfigs = (a: PartialConfig, b: PartialConfig): PartialConfig => ({ 主持人：b.主持人?? a. 主机，端口：b.端口？ a.端口 }) ## 幺半群 Monoid 是具有单位元（空）的半群。空元素满足： `concat(empty, a) === a` 和 `concat(a,empty) === a` ### 基本幺半群用法从 'fp-ts/Monoid' 导入 * as M 从 'fp-ts/number' 导入 * as N 从 'fp-ts/string' 导入 * as Str 从 'fp-ts/Array' 导入 * as A 从'fp-ts/function'导入{管道} // 内置幺半群 const sum = M.concatAll(N.MonoidSum)([1, 2, 3, 4, 5]) // 15 常量产品 = M.concatAll(N.MonoidProduct)([1, 2, 3, 4, 5]) // 120 const concatenated = M.concatAll(Str.Monoid)(['a', 'b', 'c']) // 'abc' // 空值 N.MonoidSum.empty // 0 N.MonoidProduct.empty // 1 Str.Monoid.empty // '' A.getMonoid().empty // [] ### 自定义 Monoid 实例从 'fp-ts/Monoid' 导入 * as M 从'fp-ts/function'导入{管道} // 布尔 AND 的幺半群 const MonoidAll: M.Monoid = { 连接：(x, y) => x && y, 空：真 } // 布尔 OR 的幺半群 const MonoidAny: M.Monoid = { 连接： (x, y) => x ||是，空：假 } // 用法：检查是否所有验证都通过 const allValid = M.concatAll(MonoidAll)([true, true, false, true]) // false const anyValid = M.concatAll(MonoidAny)([false, false, true, false]) // true ### 实际示例：组合结果从 'fp-ts/Monoid' 导入 * as M 从 'fp-ts/Array' 导入 * as A 从'fp-ts/function'导入{管道} // 聚合结果类型接口聚合结果{ 只读totalCount：数量只读 successCount: 数量只读错误计数：数量只读错误：ReadonlyArray 只读处理时间Ms：数字 } // Monoid 用于合并聚合结果 const AggregationResultMonoid: M.Monoid = { 连接：（a，b）=>（{ 总计数：a.totalCount + b.totalCount，成功计数：a.成功计数 + b.成功计数，错误计数：a.错误计数 + b.错误计数，错误：[...a.错误，...b.错误]，处理时间：a.处理时间+b.处理时间 }), 空：{ 总数: 0, 成功次数: 0, 错误计数：0，错误：[]，处理时间：0 } } // 处理项目并组合结果 const processItem = (item: Item): AggregationResult => { 常量开始 = Date.now() 尝试{ 处理（项目）返回{ 总数: 1, 成功次数：1，错误计数：0，错误：[]， processingTimeMs: Date.now() - 开始 } } 捕获 (e) { 返回{ 总数: 1, 成功次数: 0, 错误计数：1，错误：[e实例错误？ e.message : '未知错误'], processingTimeMs: Date.now() - 开始 } } } // 合并所有结果 const processAll = (items: ReadonlyArray): AggregationResult => 管道（物品， A.map(processItem), M.concatAll(AggregationResultMonoid) ） ### 统计幺半群从 'fp-ts/Monoid' 导入 * as M 界面统计{ 只读计数：数量只读总和：数字只读最小值：数字只读最大值：数量 } const StatisticsMonoid: M.Monoid<统计> = { 连接：（a，b）=>（{ 计数：a.count + b.count，求和：a.sum + b.sum，分钟：Math.min(a.min, b.min), 最大值：Math.max(a.max, b.max) }), 空：{ 计数：0，总和：0，分钟：无穷大，最大值：-无穷大 } } // 根据单个值创建统计数据 const fromNumber = (n: 数字): 统计 => ({ 计数：1，总和：n，分钟：n，最大值：n }) // 计算数组的统计信息 constcalculateStats=（数字：ReadonlyArray<数字>）：统计=> 管道（数字， A.map(fromNumber), M.concatAll(统计Monoid) ）常量统计 = 计算统计([5,2,8,1,9]) // { 计数：5，总和：25，最小值：1，最大值：9 } // 也可以计算平均值 const 平均值 = (s: 统计数据): 数量 => s.count === 0 ? 0 : s.sum / s.count ## Eq 类型类 Eq 定义类型的相等比较。 ### 基本方程用法从 'fp-ts/Eq' 导入 * 作为 Eq 从 'fp-ts/number' 导入 * as N 从 'fp-ts/string' 导入 * as Str 从 'fp-ts/Array' 导入 * as A 从'fp-ts/function'导入{管道} // 内置 Eq 实例 N.Eq.equals(1, 1) // true Str.Eq.equals('hello', 'hello') // true // 数组的等式 const numberArrayEq = A.getEq(N.Eq) numberArrayEq.equals([1, 2, 3], [1, 2, 3]) // true numberArrayEq.equals([1, 2, 3], [1, 2]) // false ### 自定义 Eq 实例从 'fp-ts/Eq' 导入 * 作为 Eq 从'fp-ts/function'导入{管道} 界面用户{ 只读 ID：字符串只读电子邮件：字符串只读名称：字符串 } // 仅通过 ID 进行等式 const UserEqById: Eq.Eq<用户> = Eq.contramap((用户：用户) => user.id)(Str.Eq) // 所有字段均等 const UserEqFull: Eq.Eq = Eq.struct({ id：Str.Eq，电子邮件：Str.Eq，名称：Str.Eq }) // 用法 const user1: 用户 = { id: '1', 电子邮件: 'a@b.com', 姓名: 'Alice' } const user2: User = { id: '1', email: ' different@b.com', name: 'Alice Updated' } UserEqById.equals(user1, user2) // true（相同ID） UserEqFull.equals(user1, user2) // false（不同的电子邮件） ### 实际示例：重复数据删除从 'fp-ts/Eq' 导入 * 作为 Eq 从 'fp-ts/Array' 导入 * as A 从'fp-ts/function'导入{管道} 接口产品{ 只读 sku：字符串只读名称：字符串只读价格：数量 } const ProductEqBySku: Eq.Eq<产品> = 管道( 应力方程， Eq.contramap((p: 产品) => p.sku) ） // 按SKU删除重复项 const uniqueProducts = A.uniq(ProductEqBySku) 常量产品：产品[] = [ { sku: 'A001', 名称: '小部件', 价格: 10 }, { sku: 'A002', 名称: '小工具', 价格: 20 }, { sku: 'A001', name: 'Widget Updated', Price: 15 }, // 重复的 SKU ] const unique = uniqueProducts(产品) // [{ sku: 'A001', 名称: '小部件', 价格: 10 }, { sku: 'A002', 名称: '小工具', 价格: 20 }] // 检查数组是否包含元素 const hasProduct = A.elem(ProductEqBySku) hasProduct({ sku: 'A001', 名称: '', 价格: 0 })(products) // true ### 不区分大小写的字符串 Eq 从 'fp-ts/Eq' 导入 * 作为 Eq const EqCaseInsensitive: Eq.Eq<字符串> = { 等于： (x, y) => x.toLowerCase() === y.toLowerCase() } EqCaseInsensitive.equals('Hello', 'hello') // true EqCaseInsensitive.equals('WORLD', 'world') // true // 与用户电子邮件一起使用 const UserEqByEmail: Eq.Eq<用户> = 管道( Eq不区分大小写， Eq.contramap((u: 用户) => u.email) ） ## 订单类型类 Ord 通过排序/比较功能扩展了 Eq。 ### 基本订单使用从 'fp-ts/Ord' 导入 * 作为 Ord 从 'fp-ts/number' 导入 * as N 从 'fp-ts/string' 导入 * as Str 从 'fp-ts/Array' 导入 * as A 从'fp-ts/function'导入{管道} // 内置Ord实例 Ord.lt(N.Ord)(1, 2) // 真 (1 < 2) Ord.gt(N.Ord)(5, 3) // 真 (5 > 3) Ord.leq(N.Ord)(2, 2) // 真 (2 <= 2) Ord.geq(N.Ord)(3, 2) // 真 (3 >= 2) // 排序常量数字 = [3, 1, 4, 1, 5, 9, 2, 6] const 排序 = A.sort(N.Ord)(numbers) // [1, 1, 2, 3, 4, 5, 6, 9] // 颠倒顺序 const 降序 = A.sort(Ord.reverse(N.Ord))(numbers) // [9, 6, 5, 4, 3, 2, 1, 1] // 最小值和最大值 const 最小值 = Ord.min(N.Ord)(5, 3) // 3 const 最大值 = Ord.max(N.Ord)(5, 3) // 5 ### 自定义订单实例从 'fp-ts/Ord' 导入 * 作为 Ord 从 'fp-ts/Array' 导入 * as A 从'fp-ts/function'导入{管道} 接口产品{ 只读名称：字符串只读价格：数量只读评级：数字只读创建时间：日期 } // 按价格排序 const OrdByPrice: Ord.Ord<产品> = 管道( N.Ord， Ord.contramap((p: 产品) => p.price) ） // 按评级排序（降序 - 最高的在前） const OrdByRatingDesc: Ord.Ord<产品> = 管道( N.Ord， Ord.contramap((p: 产品) => p. rating), 逆序） // 按日期排序（最新的在前） const OrdByDateDesc: Ord.Ord<产品> = 管道( N.Ord， Ord.contramap((p: Product) => p.createdAt.getTime()), 逆序） // 按价格对产品进行排序 const sortByPrice = A.sort(OrdByPrice) // 按评分排序（最高的在前） const sortByRating = A.sort(OrdByRatingDesc) ### 复合排序从 'fp-ts/Ord' 导入 * 作为 Ord 从 'fp-ts/Array' 导入 * as A 从'fp-ts/function'导入{管道} 从 'fp-ts/Monoid' 导入 * as M 接口员工{ 只读部门：字符串只读名称：字符串只读工资：数字只读开始日期：日期 } // 主要：部门（按字母顺序） // 第二：工资（降序） // 第三级：名称（按字母顺序排列） const OrdByDepartment: Ord.Ord<员工> = 管道( 斯特.奥德， Ord.contramap((e: 员工) => e.部门) ） const OrdBySalaryDesc: Ord.Ord<员工> = 管道( N.Ord， Ord.contramap((e: 员工) => e.salary), 逆序） const OrdByName: Ord.Ord<员工> = 管道( 斯特.奥德， Ord.contramap((e: 员工) => e.name) ） // 将排序与幺半群结合起来 const EmployeeOrd: Ord.Ord = M.concatAll(Ord.getMonoid())([ 按部门排序，按工资描述排序，按名称排序 ]）常量员工：员工[] = [ { 部门: '工程', 姓名: 'Alice', 工资: 100000, startDate: new Date() }, { 部门: '工程', 姓名: '鲍勃', 工资: 120000, startDate: new Date() }, { 部门: '销售', 姓名: '查理', 工资: 90000, startDate: new Date() }, { 部门: '工程', 姓名: '戴安娜', 工资: 120000, startDate: new Date() }, ] const 排序 = A.sort(EmployeeOrd)(employees) // 工程：Bob (120k)、Diana (120k - 按字母顺序)、Alice (100k) // 销售额：查理 (90k) ### 实际示例：排序和过滤从 'fp-ts/Ord' 导入 * 作为 Ord 从 'fp-ts/Array' 导入 * as A 从 'fp-ts/Option' 导入 * as O 从'fp-ts/function'导入{管道} 接口任务{ 只读 ID：字符串只读标题：字符串只读优先级：'低' | '中等' | '高' | “批评” 只读 dueDate: O.Option 只读完成：布尔值 } // 优先级排序（关键>高>中>低） constpriorityOrder: Record = { 关键：4，高：3，中：2，低：1 } const OrdByPriority: Ord.Ord<任务> = 管道( N.Ord， Ord.contramap((t: 任务) =>priorityOrder[t.priority]), Ord.reverse // 优先级最高的在前） // 截止日期排序（最早的第一个，没有日期最后） const OrdByDueDate: Ord.Ord<任务> = 管道( O.getOrd(N.Ord), Ord.contramap((t: 任务) => 管道(t.dueDate, O.map(d => d.getTime()))) ） // 组合：首先是不完整，然后是按优先级，然后是按截止日期 const TaskOrd: Ord.Ord<任务> = M.concatAll(Ord.getMonoid<任务>())([ 管道（ Ord.trivial, // 布尔值没有自然顺序 Ord.contramap((t: Task) => t.completed ? 1 : 0) // 未完成 (0) 之前完成 (1) ), 按优先级排序，按到期日订购 ]） // 获取前N个任务 const getTopTasks = (n: 数字) => (任务: 任务[]): 任务[] => 管道（任务， A.filter(t => !t.completed), A.排序(任务顺序), A.左转(n) ） ## 使用 fp-ts 类型类实例 ### 从模块获取实例从 'fp-ts/Option' 导入 * as O 从 'fp-ts/Either' 导入 * as E 从 'fp-ts/Array' 导入 * as A 从 'fp-ts/Record' 导入 * as R 从 'fp-ts/NonEmptyArray' 导入 * 作为 NEA // 每个模块导出类型类实例 // 选项实例 O.Eq // Eq> 给定 Eq O.Ord // Ord> 给定 Ord O.Semigroup // 使用Apply的半群 O.Monoid // Monoid，None 为空 // 数组实例 A.getEq // (Eq ) => Eq> A.getOrd // (Ord ) => Ord> A.getMonoid // () => Monoid> A.getSemigroup // () => Semigroup> // 记录实例 R.getEq // 记录方程 R.getMonoid // 用于记录的 Monoid ### 组合类型类从 'fp-ts/Eq' 导入 * 作为 Eq 从 'fp-ts/Ord' 导入 * 作为 Ord 从 'fp-ts/Semigroup' 导入 * as S 从 'fp-ts/Monoid' 导入 * as M 从 'fp-ts/Option' 导入 * as O 从'fp-ts/function'导入{管道} 接口购物车项目{ 只读产品ID：字符串只读数量：数量只读价格：数量 } // 购物车商品的等式（按产品 ID） const CartItemEq: Eq.Eq = 管道( 应力方程， Eq.contramap((项目：CartItem) => item.productId) ） // 合并相同产品数量的半群 const CartItemSemigroup: S.Semigroup = { 连接：（a，b）=>（{ 产品Id：a.产品Id，数量：a.数量 + b.数量， Price: a.price // 保持原价 }) } // 合并购物车商品，合并重复项的数量 const mergeCartItems = (项目: CartItem[]): CartItem[] => { const 分组 = items.reduce((acc, item) => { const 现有 = acc.get(item.productId) 如果（现有）{ acc.set(item.productId, CartItemSemigroup.concat(现有, item)) } 否则{ acc.set(item.productId, item) } 返回帐户 }, new Map<字符串, CartItem>()) 返回 Array.from(grouped.values()) } // 使用 Monoid 计算购物车总数接口购物车总计{ 只读 itemCount: 数量只读小计：数量 } const CartTotalMonoid: M.Monoid = { 连接：（a，b）=>（{ itemCount：a.itemCount + b.itemCount，小计：a.小计 + b.小计 }), 空：{ itemCount：0，小计：0 } } constcalculateTotal = (items: CartItem[]): CartTotal => 管道（物品， A.map(项目 => ({ itemCount: 项目.数量, 小计：商品.数量 * 商品.价格 }））， M.concatAll(CartTotalMonoid) ） ### 构建特定领域的类型类从 'fp-ts/Eq' 导入 * 作为 Eq 从 'fp-ts/Ord' 导入 * 作为 Ord 从 'fp-ts/Semigroup' 导入 * as S 从 'fp-ts/Monoid' 导入 * as M 从'fp-ts/function'导入{管道} // 域：资金处理接口钱{ 只读金额：数量只读货币：字符串 } // 只允许对相同货币进行操作 const MoneyEq: Eq.Eq = Eq.struct({ 金额：N.Eq，货币：Str.Eq }) // 比较金额（仅限相同货币） const MoneyOrd: Ord.Ord = 管道( N.Ord， Ord.contramap((m: 金钱) => m.amount) ） // 添加资金（如果货币不同则抛出异常） const MoneySemigroup = (货币: 字符串): S.Semigroup => ({ 连接：（a，b）=> { if (a.currency !== 货币 || b.currency !== 货币) { 抛出新错误（'不能组合不同的货币'） } 返回 { 金额：a.金额 + b.金额，货币 } } }) // 使用选项进行安全资金添加 const addMoney = (a: 金钱, b: 金钱): O.Option => a.货币 === b.货币？ O.some({ 金额：a.金额 + b.金额，货币：a.货币 }) : O.无 // 特定货币的 Monoid const MoneyMonoid = (货币: 字符串): M.Monoid => ({ ...MoneySemigroup(货币), 空：{金额：0，货币} }) // 将所有美元金额相加 const TotalUSD = (金额: Money[]): Money => 管道（金额， A.filter(m => m.currency === 'USD'), M.concatAll(MoneyMonoid('USD')) ） ## 实用领域建模示例 ### 示例1：电商订单系统从 'fp-ts/Either' 导入 * as E 从 'fp-ts/Option' 导入 * as O 从 'fp-ts/Array' 导入 * as A 从 'fp-ts/Monoid' 导入 * as M 从'fp-ts/function'导入{管道} // 订单状态的 Sum 类型输入订单状态= | { readonly _tag: '草稿' } | { readonly _tag: '待处理';只读提交时间：日期 } | { readonly _tag: '已付费';只读 payAt: 日期；只读 transactionId: 字符串 } | { readonly _tag: '已发货';只读发货时间：日期；只读跟踪编号：字符串 } | { readonly _tag: '已交付';只读交付时间：日期 } | { readonly _tag: '已取消';只读取消于：日期；只读原因：字符串 } | { readonly _tag: '已退款';只读退款时间：日期；只读退款金额：数字 } // 智能构造函数常量订单状态 = { 草稿: (): OrderStatus => ({ _tag: '草稿' }), 待处理：（subscribedAt：日期）：OrderStatus =>（{_tag：'待处理'，subscribedAt }），已付款：（paidAt：日期，transactionId：字符串）：OrderStatus =>（{_tag：'已付款'，paidAt，transactionId }），发货：（shippedAt：日期，trackingNumber：字符串）：OrderStatus =>（{_tag：'发货'，shippedAt，trackingNumber }），已交付：（deliveredAt：日期）：OrderStatus =>（{_tag：'已交付'，deliveredAt }），已取消：（cancelledAt：日期，原因：字符串）：OrderStatus =>（{_tag：'已取消'，cancelledAt，原因}），已退款：（refundedAt：日期，refundAmount：数量）：OrderStatus =>（{ _tag：'已退款'，refundedAt，refundAmount }） } // 模式匹配 const FoldOrderStatus = （处理程序：{ 草稿：() => R 待处理：（提交时间：日期）=> R 已付费：（paidAt：日期，transactionId：字符串）=> R 已发货：（shippedAt：日期，trackingNumber：字符串）=> R 已交付：（交付时间：日期）=> R 已取消：（cancelledAt：日期，原因：字符串）=> R 已退款：(refundedAt: 日期，refundAmount: 数字) => R }) => （状态：OrderStatus）：R => { 开关（状态._tag）{ case 'Draft': 返回 handlers.Draft() case 'Pending': 返回 handlers.Pending(status.subscribedAt) case 'Paid': return handlers.Paid(status.paidAt, status.transactionId) case 'Shipped': 返回 handlers.Shipped(status.shippedAt, status.trackingNumber) case 'Delivered': 返回 handlers.Delivered(status.deliveredAt) case 'Cancelled': return handlers.Cancelled(status.cancelledAt, status.reason) case 'Refunded': return handlers.Refunded(status.refundedAt, status.refundAmount) } } // 订单的产品类型接口顺序{ 只读 ID：字符串只读 customerId：字符串只读项目：ReadonlyArray 只读状态：OrderStatus 只读送货地址：地址只读 billingAddress: 地址只读创建时间：日期只读更新时间：日期 } 接口订单项{ 只读产品ID：字符串只读产品名称：字符串只读数量：数量只读单位价格：数量只读折扣：数量 } 接口地址{ 只读 line1: 字符串只读第2行：O.Option<字符串> 只读城市：字符串只读状态：字符串只读邮政编码：字符串只读国家/地区：字符串 } // 订单总数的 Monoid 接口订单总计{ 只读小计：数量只读折扣：数量只读税：数字只读运费：数量只读总数：数量 } const OrderTotalsMonoid: M.Monoid = M.struct({ 小计：N.MonoidSum，折扣：N.MonoidSum，税：N.MonoidSum，运输：N.MonoidSum，总计：N.MonoidSum }) constcalculateItemTotal =（项目：OrderItem）：OrderTotals => { const 小计 = item.quantity * item.unitPrice 常量折扣 = item.discount 返回{ 小计，折扣， tax: 0, // 单独计算运费: 0, 总计：小计 - 折扣 } } constcalculateOrderTotals =（订单：订单，税率：数字，运费：数字）：OrderTotals => { const itemTotals = 管道( 订单项目， A.map(计算ItemTotal), M.concatAll(OrderTotalsMonoid) ）常量税 = (itemTotals.subtotal - itemTotals.discount) * 税费 const 总计 = itemTotals.subtotal - itemTotals.discount + 税费 + 运费返回{ ...项目总计，税，运费：运费，总计 } } // 带验证的状态转换 const canTransition = (从: OrderStatus, 到: OrderStatus['_tag']): boolean => 折叠订单状态({ 草稿：() => 至 === '待处理' || === '已取消', 待处理：() => 至 === '已付费' || === '已取消', 已付款：() => 至 === '已发货' || ===“已退款”，已发货：() => 至 === '已交付' || ===“已退款”，已交付：() => 至 === '已退款', 取消: () => false, 已退款：() => false })(来自) ### 示例 2：配置管理从 'fp-ts/Semigroup' 导入 * as S 从 'fp-ts/Option' 导入 * as O 从 'fp-ts/Array' 导入 * as A 从'fp-ts/function'导入{管道} // 日志级别的求和类型类型 LogLevel = '调试' | '信息' | '警告' | ‘错误’ const LogLevelOrd: Ord.Ord = 管道( N.Ord， Ord.contramap((级别: LogLevel) => { const order: Record = { 调试: 0, 信息: 1, 警告: 2, 错误: 3 } 退货订单[等级] }) ） // 应用配置的产品类型接口应用程序配置{ 只读服务器：ServerConfig 只读数据库：DatabaseConfig 只读日志记录：LoggingConfig 只读功能：FeatureFlags } 接口服务器配置{ 只读主机：字符串只读端口：号码只读超时：数字只读最大连接数：数量 } 接口数据库配置{ 只读主机：字符串只读端口：号码只读数据库：字符串只读池大小：数字只读 ssl：布尔值 } 接口日志配置{ 只读级别：LogLevel 只读格式：'json' | '文本' 只读输出：ReadonlyArray } 接口功能标志{ 只读 [键：字符串]：布尔值 } // 用于合并配置的半组（稍后的值覆盖） const ServerConfigSemigroup: S.Semigroup = S.struct({ 主机：S.last<字符串>()，端口：S.last(), timeout: S.max(N.Ord), // 取更高的超时时间 maxConnections: S.max(N.Ord) // 取更高的最大连接数 }) const DatabaseConfigSemigroup: S.Semigroup = S.struct({ 主机：S.last<字符串>()，端口：S.last(), 数据库：S.last(), 池大小：S.max(N.Ord), ssl: { concat: (a, b) => a || b } // SSL（如果任一启用） }) const LoggingConfigSemigroup: S.Semigroup = { 连接：（a，b）=>（{ level: Ord.min(LogLevelOrd)(a.level, b.level), // 最详细级别 format: b.format, // 最后一种格式获胜输出： [...new Set([...a.outputs, ...b.outputs])] // 输出的并集 }) } const FeatureFlagsSemigroup: S.Semigroup = { concat: (a, b) => ({ ...a, ...b }) // 稍后的标志覆盖 } const AppConfigSemigroup: S.Semigroup = S.struct({ 服务器：ServerConfigSemigroup，数据库：DatabaseConfigSemigroup，日志记录：LoggingConfigSemigroup，特征：FeatureFlagsSemigroup }) // 从多个源加载并合并配置 const loadConfig =（来源：AppConfig[]）：AppConfig => 管道（来源， A.reduce(defaultConfig, AppConfigSemigroup.concat) ） // 用法示例常量默认配置：AppConfig = { 服务器：{主机：'localhost'，端口：3000，超时：5000，maxConnections：100}，数据库: { 主机: 'localhost', 端口: 5432, 数据库: 'app', poolSize: 10, ssl: false }, 日志记录：{级别：'信息'，格式：'文本'，输出：['控制台']}，特点：{} } const envConfig: AppConfig = { 服务器：{主机：'api.prod.com'，端口：443，超时：10000，maxConnections：1000}，数据库：{ 主机：'db.prod.com'，端口：5432，数据库：'app_prod'，poolSize：50，ssl：true }，日志记录：{级别：'警告'，格式：'json'，输出：['控制台'，'文件'，'cloudwatch']}，功能：{ newCheckout：true，betaFeature：false } } const FinalConfig = loadConfig([defaultConfig, envConfig]) ## 最佳实践 ### 1\.一致地使用判别属性 // 好：所有变体的 _tag 一致输入结果 = | { readonly _tag: '失败';只读错误：E } | { readonly _tag: '成功';只读值：A } // 不好：判别不一致类型 BadResult = | { 只读类型：'错误'；只读错误：E } | { 只读种类：'成功'；只读值：A } ### 2\.让非法国家无法代表 // 不好：允许无效的组合接口坏顺序{ 只读状态：“已发货”| “待定” 只读跟踪编号：字符串 | null // 仅对已发货有效 } // 好：sum 类型确保有效组合输入好订单= | { readonly _tag: '待处理' } | { readonly _tag: '已发货';只读跟踪编号：字符串 } ### 3\.使用智能构造函数 // 公开构造函数，而不是原始对象常量订单 = { 待处理: (): 订单 => ({ _tag: '待处理' }), 已发货：（trackingNumber：字符串）：订单=>（{_tag：'已发货'，trackingNumber }） } // 不要直接导出类型定义进行构造 // 仅通过智能构造函数导出 ### 4\.更喜欢结构类型类从 'fp-ts/Eq' 导入 * 作为 Eq 从 'fp-ts/Semigroup' 导入 * as S // 好：使用结构体从小块构建 const UserEq: Eq.Eq = Eq.struct({ id：Str.Eq，电子邮件：Str.Eq，名称：Str.Eq }) // 好：组合类型类实例 const ConfigSemigroup: S.Semigroup = S.struct({ 服务器：ServerConfigSemigroup，数据库：DatabaseConfigSemigroup }) ### 5\.保持弃牌/匹配详尽无遗 // 如果遗漏了一个案例，TypeScript 将会出错 const handleStatus =（状态：OrderStatus）：字符串=> 管道（状态，折叠订单状态({ 草稿：() => '草稿', 待处理：() => '待处理', 已付费：() => '已付费', 已发货：() => '已发货', 已交付：() => '已交付', 已取消：() => '已取消', 已退款：() => '已退款' // 缺少大小写会导致编译错误 }) ） ## 要避免的反模式 ### 不要使用枚举作为求和类型 // 不好：枚举不携带关联数据枚举订单状态{ 待定，已发货，已交付 } // 已发货的追踪号码去哪里？ // 好：受歧视的联合体携带数据输入订单状态= | { readonly _tag: '待处理' } | { readonly _tag: '已发货';只读跟踪编号：字符串 } | { readonly _tag: '已交付';只读交付时间：日期 } ### 不要错误地混合类型类 // 不好：当你只需要 Eq 时使用 Ord const findUser = (用户: User[], 目标: User) => users.find(u => Ord.equals(UserOrd)(u, target)) // Ord.equals 不存在 // 好：使用正确的类型类 const findUser = (用户: User[], 目标: User) => users.find(u => UserEq.equals(u, target)) ### 不要忘记幺半群的身份法则 // 不好：这不是一个有效的 Monoid const BadMonoid: M.Monoid = { concat: (a, b) => a + b + 1, // 加 1 违反恒等律空：0 } // concat(0, 5) = 6，而不是 5！ // 好：尊重身份法 const GoodMonoid: M.Monoid = { 连接：（a，b）=> a + b，空：0 } // 连接(0, 5) = 5 ✓

fp-ts 代数数据类型和类型类

包含技能