我一直在比较 OOP 和 FP 方法，但我无法专注于函数式编程中的一件事 - 在数据结构中保持不变量。
例如想象以下要求。
我们有一个项目列表，每个项目都有任务列表和分配成员列表。 每个任务都可以分配一个工作人员，但只能从项目分配成员列表中分配。
我可以想象如何在 OOP 语言中解决这个问题，例如在 Java 中，通过添加必需的检查和异常，我认为这会导致代码更健壮。
但是由于数据与 FP 中的行为分离，我应该如何解决 FP 中的相同问题，比如在 Clojure 或 Haskell 中？
【问题讨论】：
标签： haskell clojure functional-programming invariants
在 Clojure 中，可以在任何函数上指定任意 :pre 和 :post 条件。这是来自documentation 的示例：
(defn constrained-sqr [x]
{:pre [(pos? x)]
:post [(> % 16), (< % 225)]}
(* x x))
还有一个非常有趣的库core.contracts 在 Clojure 中实现了contracts。
【讨论】：
您的问题非常笼统，可以使用很多策略来解决相关问题，但本质上，检查不变量（在运行时）比在 OOP 中“相等”
assign :: Task -> Worker -> Either String Task
assign task worker =
if not (taskProject task) `containsWorker` worker
then Left "You can't assign..."
else Right $ task { taskWorkers = worker : taskWorkers task }
一种常见的行为是隐藏data 构造函数（如Task、Worker 和Project），OOP 对应的是写private 构造函数。
module Scheduler (
Task -- instead `Task (..)`
, Worker -- instead `Worker (..)`
...
, assign
, createTask
, createWorker
...
) where
（我不知道当前 Haskell 对 friend、protected 的支持，...对应的可能不存在，你可以找到很多带有私有对象的 Some.Module.Internals.Something 的 Haskell 模块）
主要问题是如何构建整个程序以实现所需的行为。
Real World Haskell 是了解这一点的一个很好的起点，或者按照相关问题 Large-scale design in Haskell? 的建议
另一方面，关于 Haskell 中的前置/后置条件，您可以阅读 What are the options for precondition checking in Haskell。
【讨论】：
您说数据与 FP 语言中的行为“分离”，但在 Haskell（我不知道 Clojure）中，您可以很容易地在模块中定义数据结构，将其定义设为私有，并且仅将函数导出到操纵数据。
换句话说，Haskell 没有（OO 风格的）类，但它仍然有封装。
【讨论】：
JoseJuan 和 MathematicalOrchid 讨论了在公开类型和接口的同时隐藏构造函数的关键点，但是在 Haskell 中还有另一种管理某些类型不变量的技术：在类型系统中对它们进行编码。代数数据类型在一定程度上是自行完成的：
data Tree a = Tri (Tree a) a (Tree a) a (Tree a)
| Bin (Tree a) a (Tree a)
| Tip
比
更受限制newtype Tree a = Tree [a] [Tree a]
但您可以使用嵌套类型、幻像类型和 GADT 走得更远。例如，Data.Sequence 定义
newtype Elem a = Elem a
data Node a = Node2 !Int a a | Node3 !Int a a a
data Digit a = One a | Two a a | Three a a a | Four a a a a
data FingerTree a = Empty
| Single a
| Deep !Int (Digit a)
(FingerTree (Node a))
(Digit a)
newtype Seq a = Seq (FingerTree (Elem a))
请注意，深层FingerTree a 包含FingerTree (Node a)。这称为“嵌套”或“非常规”类型；它确保每一层的 2-3 棵树比上一层的树深一棵。
使用幻像类型和 GADT 可以以不同方式维护相同的形状不变量（但效率较低，事实证明）：
{-# LANGUAGE GADTs, DataKinds, KindSignatures #-}
data Nat = Z | S Nat
-- This is a GADT; n is a phantom type
data Tree23 (n::Nat) a where
Elem :: a -> Tree23 Z a
Node2 :: !Int -> Tree23 n a ->
Tree23 n a -> Tree23 (S n) a
Node3 :: !Int -> Tree23 n a -> Tree23 n a ->
Tree23 n a -> Tree23 (S n) a
-- n is again a phantom type
data Digit (n::Nat) a
= One (Tree23 n a)
| Two (Tree23 n a) (Tree23 n a)
| Three (Tree23 n a) (Tree23 n a) (Tree23 n a)
| Four (Tree23 n a) (Tree23 n a) (Tree23 n a) (Tree23 n a)
-- n is still a phantom type
data FingerTree (n::Nat) a
= Empty
| Single a
| Deep !Int (Digit n a) (FingerTree (S n) a) (Digit n a)
在这个版本中，手指树的级别是使用幻像类型“跟踪”的，然后使用 GADT 强制 2-3 棵树的高度与之匹配。
【讨论】：