anchor.diff:  }
   ----
   
  -However, there is a possible problem with this approach (I haven't
  -tested it). If your test suites are running in parallel, this
  -set/reset of the default instance will be problematic. I don't
  -recommend this approach unless you know what you are doing.
  +However, there is a potential problem with this approach.
  +If your test suites are running in parallel, this
  +set/reset of the default instance will be problematic. This approach is not
  +recommended unless you know what you are doing.
   
   One safe way of doing this is to use the stackable nature of the
   `Makers`:
  
positive.code: ----
  
  You can use the `apply` or `vend` method on the FactoryMaker directly,
  which will give you the instance you need. I'll be using `vend` for
  further examples just so that it is clear what is happening.
  
  Calling `DependencyFactory.sequenceNumberService.vend` will return a
  new number every time, since that is how it has been setup. This is, in
  spring terminology, https://docs.spring.io/spring/docs/current/spring-framework-reference/html/beans.html#beans-factory-scopes-prototype[the prototype scope].
  
  An alternative way is to use `DependencyFactory.inject`. But it
  returns `Box` and it is only needed if don't have a FactoryMaker for a
  given dependency. Which brings us to the fact that there are other
  ways of registering dependencies apart from the FactoryMaker. For ex.
  
  
negative.code: on production/staging mode or some other mode (e.g. development). The
  `emailService` is a singleton dependency. That is, everyone
  who injects this dependency will get the same instance throughout the
  app. This is sometimes referred to as the `singleton` scope.
  
  Note that the `FactoryMaker` constructor takes a stock scala function that
  returns an instance of the needed type -- a http://www.scala-lang.org/api/current/scala/Function0.html[`Function0`] to
  be precise. If you pass in a pre-created instance, as we are
  doing in the case of `emailService`, that instance will always be
  returned when this dependency is injected (scala promotes that
  instance to a `Function0`).
  
  However, since this is a normal scala function, you can write whatever
  you want within that function. For ex. as the `sequenceNumberService`
  illustrates, you can generate a new instance every time it needs to be
  injected. This is sometimes called the `prototype` scope. Instances could be generated every time, or they could be
  generated fresh if some condition is met and so on and so forth.
  
  Here's how you can use these dependencies:
  