scala - 传递的函数参数的协方差

Question

我已经尝试在Scala中实现StateMachine，但是我遇到了类型系统的问题，这让我感到莫名其妙。在下面的代码中，我需要让Guard函数接受StateMachine的预期子类的参数。不幸的是，由于FunctionN参数的类型参数是互变的，因此我不确定如何实现。


类Transition [S，+ M <：StateMachine [S]]（开始：S，结束：S，var保护：Option [M => Boolean]）{
//上方的编译器错误：^^协变类型M在类型=> Option [M => Boolean]方法守卫^^的相反位置发生
val startState =开始
val endState =结束

def willFollow（stateMachine：M，withGuard：Boolean）=
//上面的编译器错误：^^协变量类型M发生在状态值M的类型M的反位置中
如果（！withGuard && guard == None）true;
其他（withGuard && guard.get（stateMachine））
}

类EpsilonTransition [S，M <：StateMachine [S]]（开始：S，end：S）扩展了Transition [S，M]（开始，结束，无）

类StateMachine [S]（transitions：Set [Transition [S，StateMachine [S]]]，initialStates：Set [S]）{
私有val stateDrains = transitions.groupBy（_。startState）;
私有var activeStates = initialStates

def act（）= {
var entryStates = Set [S]（）
var exitStates = Set [S]（）

stateDrains.foreach {排水=>
val（exitState，transitionsOut）=消耗

//遵循非ε过渡
transitionsOut.filter（_。willFollow（this，true））。foreach {transition =>
exitStates + = transition.startState
entryStates + = transition.endState
}
}

//对于所有退出状态，我们将状态映射到一组过渡，并且将所有组“展平”为一组大过渡
//，然后将其过滤掉那些没有保护的人（ε过渡）。结果转换列表
//所有都包含我们将映射到的endStates。所有这些最终状态都将附加到当前的一组输入状态中。
entryStates = entryStates ++（exitStates.flatMap（stateDrains（_））。filter（_。willFollow（this，false））。map（_。endState））

//仅排除我们尚未重新进入的退出状态
//然后包含新输入的状态
activeStates =（（（activeStates-（exitStates-entryStates））++ entryStates）
}

覆盖def toString = activeStates.toString
}

对象HvacState扩展了枚举{
类型HvacState =值
val空调，加热器，风扇=值
}
导入HvacState._

对象HvacTransitions {
val autoFan = new EpsilonTransition [HvacState，HVac]（空调，风扇）
val turnOffAc = new Transition [HvacState，HVac]（空调，风扇，某些（_。温度75））
val HeaterToFan = new Transition [HvacState，HVac]（加热器，风扇，某些（_。温度> 50））
}
导入HvacTransitions。_

HVac类扩展了StateMachine [HvacState]（Set（autoFan，turnOffAc，AcToHeater，HeaterToAc，HeaterToFan），Set（heater））{
无功温度= 40
}

Answer 1

您的过渡仅适用于某种类型的状态，也适用于某种类型的状态机，因此这两个类型参数为S和M。例如，最后，您的转换可能取决于温度，这是StateMachine的属性，而不仅仅是State的属性。

不知何故，状态机应该只具有与其兼容的转换。没有温度的状态机上不应允许需要访问温度的转换。类型系统将强制执行该操作。但是，您的代码没有为此做任何准备。

相反，您需要让StateMachine类获得一组Transition [S，StateMachine [S]]。这行得通，但结果是StateMachine仅接受“标准”转换，不需要计算机提供任何特殊的转换。您可以定义需要特殊机器（带有温度）的过渡，但是即使兼容特殊过渡，机器也不会接受任何特殊过渡。

然后是带有温度的Hvac机器。您尝试给它传递特殊的过渡，这些过渡只能在Hvac机器上运行（获取温度）。但是祖先的构造函数只接受标准转换。编译器拒绝。它表明，如果Transition在M中是协变的，那就可以了。这是对的，除了Transition在M中不能是协变的。它将机器作为输入。协变过渡意味着，如果它可以在非常特殊的机器上运行，它也必须也可以在不太特殊的机器上运行。不是你想要的。

您需要做的是让StandardMachine类接受特殊的转换，现在它会拒绝这些转换，但是当然只有与计算机兼容的转换（如果您不提供此保证，编译器将拒绝该代码）。
可能更简单的方法是将类型M也放入机器中，以便您可以正确表达约束。

这是一种可能的方法。首先，我们向StateMachine添加类型参数

class StateMachine[S, M](

例如，我们需要在引用StateMachine的任何地方添加M参数
class Transition[S, M <: StateMachine[S, M]]或 class Hvac extends StateMachine[HvacState, Hvac]

当然，构造函数的参数变为

class StateMachine[S,M](transitions: Set[Transition[S, M]]], ...

在这里，我们指出机器可以过渡。除了我们没有。每次我们通过 this时，它仍然无法编译，例如，将计算机转换为：

transitionsOut.filter(_.willFollow(this, true)).foreach {transition =>
                                   ^^
type mismatch;  found   : StateMachine.this.type (with underlying type StateMachine[S,M])  required: M

好吧，我们引入了类型M，但是我们没有将M传递给机器，而是传递了 this。这是一个StateMachine [S，M]，它不一定是M。我们当然希望M是机器的类型，但事实并非如此。我们讨厌声明S​​tateMachine [S，M]必须是M.我们使用自类型来做到这一点：

class StateMachine[S, M](
   transitions: Set[Transition[S, M]], 
   initialStates: Set[S]) { this: M => 
 // body of the class

}

这：M =>声明该类的每个实例都必须是通用参数M的实例。我们强制将其设为M，因此错误消失了。

然后， M <: StateMachine[S, M中的约束 Transition]出现了，我们不需要它，我们只需删除它即可： Transition[S, M]。或者，我们可以对StateMachine施加相同的约束。

这样就充分利用了类型系统，可以解决上面提到的问题，但是隔离机器状态可能更简单，也就是说，代替使用自身的 type this: M =>，而是使用一些 def machineState: M并将其传递给计算机。保护而不是 this。在这种情况下， Hvac将是 StateMachine[HvacState, Double]（或者比Double更明确地封装温度），



我的变更摘要：


过渡：去除对M的约束，去除协方差：

类Transition [S，M]（...
EpsilonTransition：消除对M的约束

EpsilonTransition类[S，M]
StateMachine：添加类型参数 M，使用 M作为过渡参数，并将 M设置为自类型：

StateMachine [S，M]类（转换：Set [Transition [S，M]]，initialStates：Set [S]）{：M =>
turnOffAcc：您添加并复制的代码中缺少运算符 <
HVac：将自身添加为第二个通用参数： class HVac extends StateMachine[HvacState]。另外，某些转换 AcToHeater和 HeaterToAc不会出现在您复制的代码中，因此我只删除了它们。