“scala 不是封闭类”答案

【问题标题】："scala is not an enclosing class"“scala 不是封闭类”
【发布时间】：2011-07-05 20:33:58
【问题描述】：

编译本规范时：

import org.specs.Specification
import org.specs.matcher.extension.ParserMatchers

class ParserSpec extends Specification with ParserMatchers {
  type Elem = Char

  "Vaadin DSL parser" should {
    "parse attributes in parentheses" in {
      DslParser.attributes must(
        succeedOn(stringReader("""(attr1="val1")""")).
          withResult(Map[String, AttrVal]("attr1" -> AttrVal("val1", "String"))))
    }
  }
}

我收到以下错误：

ParserSpec.scala:21
error: scala is not an enclosing class
withResult(Map[String, AttrVal]("attr1" -> AttrVal("val1", "String"))))
           ^

我完全不明白这里的错误信息。为什么会出现？

Scala 版本是 2.8.1，规格版本是 1.6.7.2。

DslParser.attributes 的类型为 Parser[Map[String, AttrVal]]，组合子 succeedOn 和 withResult 定义如下：

trait ParserMatchers extends Parsers with Matchers {
  case class SucceedOn[T](str: Input,
                          resultMatcherOpt: Option[Matcher[T]]) extends Matcher[Parser[T]] {
    def apply(parserBN: => Parser[T]) = {
      val parser = parserBN
      val parseResult = parser(str)
      parseResult match {
        case Success(result, remainingInput) =>
          val succParseMsg = "Parser "+parser+" succeeded on input "+str+" with result "+result
          val okMsgBuffer = new StringBuilder(succParseMsg)
          val koMsgBuffer = new StringBuilder(succParseMsg)
          val cond = resultMatcherOpt match {
            case None =>
              true
            case Some(resultMatcher) =>
              resultMatcher(result) match {
                case (success, okMessage, koMessage) =>
                  okMsgBuffer.append(" and ").append(okMessage)
                  koMsgBuffer.append(" but ").append(koMessage)
                  success
              }
          }
          (cond, okMsgBuffer.toString, koMsgBuffer.toString)
        case _ =>
          (false, "Parser succeeded", "Parser "+parser+": "+parseResult)
      }
    }

    def resultMust(resultMatcher: Matcher[T]) = this.copy(resultMatcherOpt = Some(resultMatcher))

    def withResult(expectedResult: T) = resultMust(beEqualTo(expectedResult))

    def ignoringResult = this.copy(resultMatcherOpt = None)
  }

  def succeedOn[T](str: Input, expectedResultOpt: Option[Matcher[T]] = None) =
    SucceedOn(str, expectedResultOpt)

  implicit def stringReader(str: String): Reader[Char] = new CharSequenceReader(str)
}

【问题讨论】：

标签： scala specs

【解决方案1】：

当编译器真正尝试发出类型错误或类型推断失败的信号时，可能会出现此消息。这是 scalac 中的一个错误（或错误系列）。

要定位问题，逐步添加显式类型和类型参数；将复杂的表达式分解为更小的子表达式。

对于奖励积分，请生成一个独立示例并提交错误。

【讨论】：