Produces a new “matcher producer” function of type U => Matcher[U] from the T => Matcher[T] (named f) passed to the Composifier constructor and the given T => U transformation function, g.

The result of composeTwice is the result of the following function composition expression:

(f compose g) andThen (_ compose g)

You would use composeTwice if you want to create a new matcher producer from an existing one, by transforming both the left and right sides of the expression with the same transformation function. As an example, the expression “be > 7” produces a Matcher[Int]:

scala> import org.scalatest._
import org.scalatest._

scala> import Matchers._
import Matchers._

scala> val beGreaterThanSeven = be > 7
beGreaterThanSeven: org.scalatest.matchers.Matcher[Int] = be > 7

Given this Matcher[Int], you can now use it in a should expression like this:

scala> 8 should beGreaterThanSeven

scala> 6 should beGreaterThanSeven
org.scalatest.exceptions.TestFailedException: 6 was not greater than 7
...

You can create a more general “matcher producer” function like this:

scala> val beGreaterThan = { (i: Int) => be > i }
beGreaterThan: Int => org.scalatest.matchers.Matcher[Int] = <function1>

scala> 8 should beGreaterThan (7)

scala> 8 should beGreaterThan (9)
org.scalatest.exceptions.TestFailedException: 8 was not greater than 9

Given beGreaterThan matcher producer function, you can create matcher producer function that takes a String and produces a Matcher[String] given a function from Int => String using composeTwice:

scala> val stringToInt = { (s: String) => s.toInt }
stringToInt: String => Int = <function1>

scala> val beAsIntsGreaterThan = beGreaterThan composeTwice stringToInt
beAsIntsGreaterThan: String => org.scalatest.matchers.Matcher[String] = <function1>

scala> "7" should beAsIntsGreaterThan ("6")

scala> "7" should beAsIntsGreaterThan ("8")
org.scalatest.exceptions.TestFailedException: 7 was not greater than 8
...

The composeTwice method is just a shorthand for this function composition expression:

scala> val beAsIntsGreaterThan =
    (beGreaterThan compose stringToInt) andThen (_ compose stringToInt)
beAsIntsGreaterThan: String => org.scalatest.matchers.Matcher[String] = <function1>

scala> "7" should beAsIntsGreaterThan ("6")

scala> "7" should beAsIntsGreaterThan ("8")
org.scalatest.exceptions.TestFailedException: 7 was not greater than 8

The first part of that expression, beGreaterThan compose stringToInt, gives you a new matcher producer function that given a String will produce a Matcher[Int]:

scala> val beAsIntGreaterThan = beGreaterThan compose stringToInt
beAsIntGreaterThan: String => org.scalatest.matchers.Matcher[Int] = <function1>

This compose method is inherited from Function1: on any Function1, (f compose g)(x) means f(g(x)). You can use this matcher producer like this:

scala> 7 should beAsIntGreaterThan ("6")

scala> 7 should beAsIntGreaterThan ("8")
org.scalatest.exceptions.TestFailedException: 7 was not greater than 8

To get a matcher producer that will allow you to put a string on the right-hand-side, you'll need to transform the String => Matcher[Int] to a String => Matcher[String]. To accomplish this you can first just apply the function to get a Matcher[Int], like this:

scala> val beGreaterThanEight = beAsIntGreaterThan ("8")
beGreaterThanEight: org.scalatest.matchers.Matcher[Int] = be > 8

scala> 9 should beGreaterThanEight

scala> 7 should beGreaterThanEight
org.scalatest.exceptions.TestFailedException: 7 was not greater than 8

To transform beGreaterThanEight, a Matcher[Int], to a Matcher[String], you can again use compose. A ScalaTest Matcher[T] is a Scala function type T => MatchResult. To get a Matcher[String] therefore, just call compose on the Matcher[Int] and pass in a function from String => Int:

scala> val beAsIntGreaterThanEight = beGreaterThanEight compose stringToInt
beAsIntGreaterThanEight: org.scalatest.matchers.Matcher[String] = <function1>

After the second call to compose, therefore, you have what you want:

scala> "9" should beAsIntGreaterThanEight

scala> "7" should beAsIntGreaterThanEight
org.scalatest.exceptions.TestFailedException: 7 was not greater than 8

So in summary, what the result of (beGreaterThan compose stringToInt) andThen (_ compose stringToInt) will do once it is applied to a (right-hand-side) String, is:

• Transform beGreaterThan from an Int => Matcher[Int] to a String => Matcher[Int] with the first compose
• Apply the given (right-hand-side) String to that to get a Matcher[Int] (the first part of andThen's behavior)
• Pass the resulting Matcher[Int] to the given function, _ compose stringToInt, which will transform the Matcher[Int] to a Matcher[String] (the second part of the andThen behavior).

Returns a function that given a T will return a Matcher[T] that will produce the MatchResult produced by f (passed to the Composifier constructor) with arguments transformed by the given prettify function.

Returns a function that given a T will return a Matcher[T] that will produce the MatchResult produced by f (passed to the Composifier constructor) transformed by the given prettify function.