在Scala（EclipseIDE）中使用trait和companion对象时返回值时出现问题

我已将以下代码放入Eclipse中的object.Scala文件中，只想知道“x”的值是多少（应该是3）。如果我将值放置在列表对象之外的任何位置，代码将不会编译；同时，在列表对象中运行文件时，不会产生任何输出

package work

object Work extends App {
  // These 3 lines define a simplified List type
  sealed trait List[+A]
  case object Nil extends List[Nothing]
  case class Cons[+A](head: A, tail: List[A]) extends List[A]

  // This companion object contains basic operations for the List type
  object List {
    def sum(ints: List[Int]): Int = ints match {
      case Nil => 0
      case Cons(x,xs) => x + sum(xs)
    }

    def product(ds: List[Double]): Double = ds match {
      case Nil => 1.0
      case Cons(0.0, _) => 0.0
      case Cons(x,xs) => x * product(xs)
    }

    def apply[A](as: A*): List[A] =
      if (as.isEmpty) Nil
      else Cons(as.head, apply(as.tail: _*))

    // The next line is the value that I want to return. 
    val x = List(1,2,3,4,5) match {
      case Cons(x, Cons(2, Cons(4, _))) => x
      case Nil => 42
      case Cons(x, Cons(y, Cons(3, Cons(4, _)))) => x + y 
      case Cons(h, t) => h + sum(t)
      case _ => 101
     }

  }
}

最初，我将所有内容都放在

对象Work extends App

中，以便对其进行编译，否则编译器会抱怨我缺少一个Main方法。但是，为了让“x”返回，我尝试放弃工作对象，而是在我希望看到的表达式中添加了一个Main方法，如下所示：

def main(args: Array[String]) {
      val x = List(1,2,3,4,5) match {
        case Cons(x, Cons(2, Cons(4, _))) => x
        case Nil => 42
        case Cons(x, Cons(y, Cons(3, Cons(4, _)))) => x + y case Cons(h, t) => h + sum(t)
        case _ => 101
      }
}

但是，我随后得到以下错误：

List具有参数类型为Array[String]的main方法，但 work.List将不是可运行的程序。理由：伴侣是一个朋友 trait，这意味着无法生成静态转发器

我不太清楚这是什么意思。对于如何正确地实现Main方法，我也非常困惑。我试图在List对象的正下方添加一个Main方法，封装List的所有定义和val x，结果导致了比上面更多的错误。我很困惑，还在网上搜索答案，但到目前为止，似乎没有任何东西能解决我的特定问题

任何帮助都将不胜感激

下面是我的原始帖子，包含更多信息，包括我正在做的练习的文本。要做这个练习，我需要看看表达式是如何计算的。正是出于这个原因，我通常在Scala工作表中工作，因为我可以在几秒钟内看到我的结果，但是这个特殊的练习涉及到使用一个trait和companion对象，它们的添加对我来说非常复杂，因为我知道它们在代码中是如何使用的，我不知道如何正确实施它们。

---

原职

---

我将以下代码放入EclipseIDE的Scala工作表中，然后花了大约两个小时尝试不同的方法来实现它

编译时没有错误，并且

在右侧显示评估结果 我仍然在为（2）而挣扎

当我运行上面的代码时，它会输出一个标准错误，表示缺少主参数。虽然我不太清楚

defmain（args:Array[String）{}

或

对象是如何扩展App{}

实际工作，我知道他们允许代码实际编译和运行。同时，Scala工作表过去从未要求我有一个Main方法，尽管过去我也没有在同一个文件中使用类或特征。我知道我一定遗漏了什么

我试过了

• 使用App扩展列表对象
  • 或者在其下面添加def主参数
• 为sealed trait创建一个名为“Classes”的对象并向其添加主参数
  • 或者用App扩展它
• 创建一个较大的对象“工作表”，然后在def主参数下添加以下所有内容
  • 或使用应用程序扩展“工作表”
• 在另一个EclipseIDE文件中，创建一个新的Scala Trait，在其中添加Trait和类代码，然后尝试将其导入到工作表中，意识到伴随对象列表需要存在于同一个文件中
• 将上述所有代码放入另一个文件中，尝试将该文件导入工作表，并尝试使任何列表操作正常工作（这里的问题是，我实际上不知道下面的代码属于Eclipse IDE中的哪种类型的Scala文件、对象、类或特征）

其中一些已经编译，另一些还没有，但到目前为止，没有一个工作表在右侧实际生成评估结果

这是一个练习，需要上面的代码，我一直在努力工作，只要我能真正看到我的代码是如何计算的：

让我们尝试实现几个不同的函数，以不同的方式修改列表。您可以将此函数和我们编写的其他函数放在List companion对象中

3.2实现函数tail以删除列表的第一个元素。请注意，函数需要固定的时间。如果列表为Nil，则在实现中可以做出哪些不同的选择？我们将在下一章中返回此问题

从

---

非常感谢您抽出时间。

我不知道您为什么提到将

val x

放在列表对象之外会阻止您进行编译

下面编译并生成预期输出=3

object Work extends App {
  // These 3 lines define a simplified List type
  sealed trait List[+A]
  case object Nil extends List[Nothing]
  case class Cons[+A](head: A, tail: List[A]) extends List[A]

  // This companion object contains basic operations for the List type
  object List {
    def sum(ints: List[Int]): Int = ints match {
      case Nil => 0
      case Cons(x,xs) => x + sum(xs)
    }

    def product(ds: List[Double]): Double = ds match {
      case Nil => 1.0
      case Cons(0.0, _) => 0.0
      case Cons(x,xs) => x * product(xs)
    }

    def apply[A](as: A*): List[A] =
      if (as.isEmpty) Nil
      else Cons(as.head, apply(as.tail: _*))
  }

  // The next line is the value that I want to return.
  val x = List(1,2,3,4,5) match {
    case Cons(x, Cons(2, Cons(4, _))) => x
    case Nil => 42
    case Cons(x, Cons(y, Cons(3, Cons(4, _)))) => x + y
    case Cons(h, t) => h + List.sum(t)
    case _ => 101
  }

  println(x)
}

---

我也不知道为什么。我想我尝试了太多不同的迭代，以至于当我将val x放在List对象之外时，其他东西在干扰。无论如何，在我意识到我在Eclipse中运行的文件错误后，您的代码运行了；非常感谢您的帮助！啊，我意识到了原因。这是因为我是一个新手，不太了解在分析对象和类的工作方式时，将val x置于列表对象之外，同时又去掉了工作对象，这导致Scala抱怨说，它希望在val x所在的位置有一个类或对象定义。当时我不确定如何实际解决这个问题，但由于您的代码向我展示了正确编译代码的样子，我不得不e有了更好的理解，现在我找到了另一种方法让我的代码编译并返回一个值。

object Work extends App {
  // These 3 lines define a simplified List type
  sealed trait List[+A]
  case object Nil extends List[Nothing]
  case class Cons[+A](head: A, tail: List[A]) extends List[A]

  // This companion object contains basic operations for the List type
  object List {
    def sum(ints: List[Int]): Int = ints match {
      case Nil => 0
      case Cons(x,xs) => x + sum(xs)
    }

    def product(ds: List[Double]): Double = ds match {
      case Nil => 1.0
      case Cons(0.0, _) => 0.0
      case Cons(x,xs) => x * product(xs)
    }

    def apply[A](as: A*): List[A] =
      if (as.isEmpty) Nil
      else Cons(as.head, apply(as.tail: _*))
  }

  // The next line is the value that I want to return.
  val x = List(1,2,3,4,5) match {
    case Cons(x, Cons(2, Cons(4, _))) => x
    case Nil => 42
    case Cons(x, Cons(y, Cons(3, Cons(4, _)))) => x + y
    case Cons(h, t) => h + List.sum(t)
    case _ => 101
  }

  println(x)
}