在使用不可变对象时，是否有一种特定的设计策略可用于解决大多数“鸡与蛋”问题？

来自OOP背景（Java），我自己学习Scala。虽然我很容易看到单独使用不可变对象的优点，但我很难理解如何设计这样的整个应用程序。我举一个例子：

假设我有代表“材料”及其属性的对象（我在设计游戏，所以我实际上确实有这个问题），例如水和冰。我将拥有一个拥有所有此类材料实例的“经理”。一种特性是凝固点和熔点，以及材料冻结或融化的温度。

[编辑]所有的实例都是“单例”，有点像Java枚举。

我想让“水”说在0C时冻结成“冰”，而“冰”说在1C时熔化成“水”。但是，如果水和冰是不可变的，则它们不能作为构造函数参数相互引用，因为其中一个必须首先创建，并且不能将尚未存在的另一个作为构造函数参数进行引用。我可以通过给他们两个都提供给经理的参考来解决这个问题，以便他们每次查询冻结/融化属性时都可以查询它以找到他们需要的其他材料实例，但是随后经理之间也遇到了同样的问题和材料，它们需要相互引用，但是只能在构造函数中为它们之一提供引用，因此管理器或材料不能是不变的。

他们只是无法解决这个问题，还是我需要使用“功能”编程技术或其他某种模式来解决它？

解决的办法是作弊一点。特别：

• 创建A，但未将其对B的引用初始化（因为B还不存在）。

• 创建B，并使其指向A。

• 更新A指向B。此后请勿更新A或B。

这可以显式完成（在C ++中为示例）：

struct List {
    int n;
    List *next;

    List(int n, List *next)
        : n(n), next(next);
};

// Return a list containing [0,1,0,1,...].
List *binary(void)
{
    List *a = new List(0, NULL);
    List *b = new List(1, a);
    a->next = b; // Evil, but necessary.
    return a;
}

或隐式（例如Haskell中的示例）：

binary :: [Int]
binary = a where
    a = 0 : b
    b = 1 : a

Haskell示例使用惰性评估来实现相互依赖的不可变值的错觉。值开始为：

a = 0 : <thunk>
b = 1 : a

a和b都是独立有效的正常形式。可以构造每个缺点，而无需其他变量的最终值。当评估thunk时，它将指向相同的数据b指向。

因此，如果要使两个不可变值相互指向，则必须在构造第二个值后更新第一个值，或者使用更高级别的机制来执行相同操作。

在您的特定示例中，我可以在Haskell中将其表示为：

data Material = Water {temperature :: Double}
              | Ice   {temperature :: Double}

setTemperature :: Double -> Material -> Material
setTemperature newTemp (Water _) | newTemp <= 0.0 = Ice newTemp
                                 | otherwise      = Water newTemp
setTemperature newTemp (Ice _)   | newTemp >= 1.0 = Water newTemp
                                 | otherwise      = Ice newTemp

但是，我回避了这个问题。我想象过，在一种面向对象的方法中，将一个setTemperature方法附加到每个Material构造函数的结果中，您将必须使构造函数指向彼此。如果将构造函数视为不可变值，则可以使用上面概述的方法。

在您的示例中，您正在对对象应用转换，因此我将使用类似于ApplyTransform()返回a 的方法之类的方法，BlockBase而不是尝试更改当前对象。

例如，要通过加热将IceBlock更改为WaterBlock，我会称呼类似

BlockBase currentBlock = new IceBlock();
currentBlock = currentBlock.ApplyTemperature(1); 
// currentBlock is now a WaterBlock 

并且该IceBlock.ApplyTemperature()方法将如下所示：

public class IceBlock() : BlockBase
{
    public BlockBase ApplyTemperature(int temp)
    {
        return (temp > 0 ? new WaterBlock((BlockBase)this) : this);
    }
}

打破循环的另一种方法是用某种组合语言将物质和trans变的关注点分开：

water = new Block("water");
ice = new Block("ice");

transitions = new Transitions([
    new transitions.temperature.Below(0.0, water, ice),
    new transitions.temperature.Above(0.0, ice, water),
]);

如果您要使用功能性语言，并且想实现不变性的好处，那么您应该牢记这一点。您试图定义一个可以支持一定温度范围的“冰”或“水”对象类型-为了支持不变性，则每次温度变化时都需要创建一个新对象，这很浪费。因此，请尝试使块类型和温度的概念更独立。我不知道Scala（它在我的学习列表上：-）），但是从Haskell的Joey Adams Answer借来的东西，我建议如下：

data Material = Water | Ice

blockForTemperature :: Double -> Material
blockForTemperature x = 
  if x < 0 then Ice else Water

或许：

transitionForTemperature :: Material -> Double -> Material
transitionForTemperature oldMaterial newTemp = 
  case (oldMaterial, newTemp) of
    (Ice, _) | newTemp > 0 -> Water
    (Water, _) | newTemp <= 0 -> Ice

（注意：我没有尝试运行它，我的Haskell有点生锈。）现在，转换逻辑与材料类型分离，因此不会浪费太多内存，并且（我认为）它相当更加注重功能。