这是什么样的Scala语法语法？

Question

I know the basic syntax of Scala, but in the following code, I don't understand what the describe and it constructs are doing. Are they some kind of anonymous functions or what?

class SentimentAnalyzerSpec extends FunSpec with Matchers {

  describe("sentiment analyzer") {

    it("should return POSITIVE when input has positive emotion") {
      val input = "Scala is a great general purpose language."
      val sentiment = SentimentAnalyzer.mainSentiment(input)
      sentiment should be(Sentiment.POSITIVE)
    }
  }
}

Answer 1

This is the basic DSL (Domain Specific Language) provided by ScalaTest , via the FunSuite .

describe is a method, accepting a String and a by name value which returns Unit via a multiple argument list:

protected def describe(description: String)(fun: => Unit) {
    registerNestedBranch(description, None, fun, "describeCannotAppearInsideAnIt", sourceFileName, "describe", 4, -2, None)
}

It simply uses infix notation, that is why it looks semi "magical".

it is a value which holds a class called ItWord . it has an apply method which simply registers the method you supply as a test:

/**
* Supports test (and shared test) registration in <code>FunSpec</code>s.
* This field supports syntax such as the following:
* it("should be empty")
* it should behave like nonFullStack(stackWithOneItem)
*/
protected val it = new ItWord

protected class ItWord {
  def apply(specText: String, testTags: Tag*)(testFun: => Unit) {
    engine.registerTest(specText, Transformer(testFun _), "itCannotAppearInsideAnotherItOrThey", sourceFileName, "apply", 3, -2, None, None, None, testTags: _*)
  }
}

Answer 2

These are just methods and variables inherited from the mixin traits. You can do a similar thing yourself:

trait MyDsl {
  def bar(n: Int) = 123
  def foo(s: String)(d: String) = 234
}

So if you mix it in another class, you can write

class MyClass1 extends MyDsl {
  bar(foo("hello")("hi"))
}

(note that foo is a multi parameter list function, which does not exist in Java)

Because Scala lets you omit parentheses via infix notation , ( might be omitted and replaced with { to group the parameter-expression. So it becomes:

class MyClass1 extends MyDsl {
  bar {
    foo("hello") {
      "hi"
    }
  }
}

Now, all of these definitions are actually happening inside the primary constructor of MyClass1