Scala：泛型和隐式

我必须开发类StackMachine[T]。如果T=Boolean，那么应该有逻辑运算。如果T=Int、Double、Long等，则应进行拟假手术。首先，我开发了类堆栈[T]

class Stack[T](val stack: List[T]) {
    val length: Int = stack.length
    def isEmpty: Boolean = {length == 0}
    def push(x: T): Stack[T] = {
      new Stack[T](x :: stack)
    }

     def peak: T = {
       if (this.isEmpty)
         throw new ArrayIndexOutOfBoundsException
         else stack.head
     }
    def pop(): Stack[T] = {
      if (this.isEmpty)
        throw new ArrayStoreException()
      val x :: xs = stack
      new Stack[T](xs)
    }

问题是，我不知道如何开发堆垛机。操作的存在取决于类型。 我试过这个：

case class StackMachine[T](val stack:Stack[T]){
    def const(x: T): StackMachine[T] = {new StackMachine[T](new Stack[T](this.stack.push(x).stack))}
    def dup: StackMachine[T] = {new StackMachine[T](new Stack[T](this.stack.push(this.stack.peak).stack))}
    def swap: StackMachine[T] = {
      val startStack = this.stack
      val startPeak = startStack.peak
      val secondStack = startStack.pop()
      val secondPeak = secondStack.peak
      val finalStack = secondStack.pop().push(startPeak)
      StackMachine[T](stack)
    }
    def and(): StackMachine[Boolean] = {
      val startStack = this.stack.asInstanceOf[Stack[Boolean]]
      val startPeak = startStack.peak
      val secondStack = startStack.pop()
      val secondPeak = secondStack.peak
      StackMachine[Boolean](new Stack[Boolean](secondStack.push(startPeak && secondPeak).stack))

    }

    def or: StackMachine[Boolean] = {
      val startStack = this.stack.asInstanceOf[Stack[Boolean]]
      val startPeak = startStack.peak
      val secondStack = startStack.pop()
      val secondPeak = secondStack.pop().peak
      StackMachine[Boolean](new Stack[Boolean](secondStack.push(startPeak || secondPeak).stack))
    }

    def xor: StackMachine[Boolean] = {
      val startStack = this.stack.asInstanceOf[Stack[Boolean]]
      val startPeak = startStack.peak
      val secondStack = startStack.pop()
      val secondPeak = secondStack.pop().peak
      StackMachine[Boolean](new Stack[Boolean](secondStack.push(startPeak ^ secondPeak).stack))
    }

    def sum(input : T)(implicit N: Numeric[T])  = {
      val startStack = this.stack
      val startPeak = startStack.peak
      val secondStack = startStack.pop()
      StackMachine[T](new Stack[T](secondStack.push(N.plus(startPeak,input)).stack))
    }

    def dif(input : T)(implicit N: Numeric[T])  = {
      val startStack = this.stack
      val startPeak = startStack.peak
      val secondStack = startStack.pop()
      StackMachine[T](new Stack[T](secondStack.push(N.minus(startPeak,input)).stack))
    }

    def mul(input : T)(implicit N: Numeric[T])  = {
      val startStack = this.stack
      val startPeak = startStack.peak
      val secondStack = startStack.pop()
      StackMachine[T](new Stack[T](secondStack.push(N.toDouble(startPeak).*(N.toDouble(input)).asInstanceOf[T]).stack))
    }

    def div(input : T)(implicit N: Numeric[T])  = {
      val startStack = this.stack
      val startPeak = startStack.peak
      val secondStack = startStack.pop()
      StackMachine[T](new Stack[T](secondStack.push(N.toDouble(startPeak)./(N.toDouble(input)).asInstanceOf[T]).stack))
    }

    def min(input : T)(implicit N: Numeric[T])  = {
      val startStack = this.stack
      val startPeak = startStack.peak
      val secondStack = startStack.pop()
      StackMachine[T](new Stack[T](secondStack.push(N.min(startPeak,input)).stack))
    }
    def max(input : T)(implicit N: Numeric[T])  = {
      val startStack = this.stack
      val startPeak = startStack.peak
      val secondStack = startStack.pop()
      StackMachine[T](new Stack[T](secondStack.push(N.max(startPeak,input)).stack))
    }



  }

但这是错误的，因为操作不应该有输入参数，因为所有变量都必须从堆栈中获取。更重要的是，这样我无法创建diff和mul函数。

---

我曾想将StackMachine[T]抽象并使用imlplicit对象，但失败了，因为在这种情况下，我的函数无法返回StackMachine。可能是我对隐式的理解不够透彻，或者有其他方法可以做到这一点？

那么，是的，似乎这个项目是打算用一个简单的方法来解决的

例如，对于布尔型和，请参见此小图：

密封特征行为为布尔[T]{ def和T1:T，t2:T:T } 对象行为为布尔型{ 隐式final val BooleanBehavesAsBoolean:BehavesAsBoolean[Boolean]= 新行为为布尔型[布尔型]{ 覆盖def和b1:Boolean，b2:Boolean:Boolean= b1和b2 } } 最终类StackMachine[T]堆栈：堆栈[T]{ def和implicit ev:BehavesAsBoolean[T]：选项[StackMachine[T]]= 为了{ //我更改了pop的实现以返回选项[T，Stack[T]]

---

b1，s2那么是的，这个项目似乎打算用一个简单的方法来解决

例如，对于布尔型和，请参见此小图：

密封特征行为为布尔[T]{ def和T1:T，t2:T:T } 对象行为为布尔型{ 隐式final val BooleanBehavesAsBoolean:BehavesAsBoolean[Boolean]= 新行为为布尔型[布尔型]{ 覆盖def和b1:Boolean，b2:Boolean:Boolean= b1和b2 } } 最终类StackMachine[T]堆栈：堆栈[T]{ def和implicit ev:BehavesAsBoolean[T]：选项[StackMachine[T]]= 为了{ //我更改了pop的实现以返回选项[T，Stack[T]]

---

b1，s2你可以使用def和implicit ev:T我也会这样做，但这就是任务。说实话，我不明白这种构造有什么帮助，因为ev没有布尔运算ev意味着T本身就是布尔运算，你应该能够在该方法的主体中使用T作为布尔运算。但是，如果这是预期的解决方案，你应该d已经知道了。-你能分享你任务的文字陈述吗？也许你不能因为剽窃而放弃。如果这是家庭作业，或者如果这是工作，你想解决的元问题是什么，如果这是作业，我们也可以知道你在这里要使用的主题/技巧。好的，但是我有一个类型错误匹配，因为在StackMachi中ne[布尔]新堆栈[布尔]secondStack.pushstartPeak&&secondPeak.stack secondStack.push需要T，但发现为布尔值。任务文本：在实验室工作过程中，有必要开发一个通用类。附表中给出了类变体。任务的一个特殊特征是，对正在开发的类的对象执行某些操作的含义oped取决于此类参数化的类型。此外，即使某些操作的存在也可能取决于典型参数。此功能是使用隐式对象和隐式方法参数实现的。您可以使用def和implicit ev:T我也会这样做，但这是任务。说实话，我不明白如何实现这个结构很有帮助，因为ev没有布尔运算ev意味着T本身就是一个布尔值，你应该能够在该方法的主体中使用T作为布尔值。但是，如果这是预期的解决方案，你应该已经知道了。-你能分享你任务的文字陈述吗？也许你不能，因为抄袭。也可能如果这是家庭作业，或者如果这是为了工作，您试图解决的元问题是什么，请帮助我们了解您希望在这里使用的主题/技术。好的，但是我有一个类型不匹配，因为在StackMachine[Boolean]中有一个新堆栈[Boolean]secondStack.pushstartPeak&&secondPeak.stack secondStack.push需要T，但发现为布尔值。任务文本：在实验室工作过程中，有必要开发一个通用类。附表中给出了类变体。任务的一个特殊特征是，对正在开发的类的对象执行某些操作的含义oped取决于此类参数化的类型。此外，即使某些操作的存在也可能取决于典型参数。此功能使用隐式对象和隐式方法参数实现。谢谢您的帮助谢谢您的帮助