“Scala是不是一个封闭类”

在编制本规范：“Scala是不是一个封闭类”

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) 
}

来源

2011-02-28 Alexey Romanov

此消息。这是一个bug（或bug家族）。

要找到问题，逐步添加显式类型和类型参数;将复杂表达式分解成更小的子表达式。

对于奖励积分，产生一个独立的例子并提交一个错误。

来源

2011-02-28 15:38:58 retronym

“Scala是不是一个封闭类”

回答

相关问题