anchor.diff:  doing in the case of `emailService`, that instance will always be
   returned when this dependency is injected (scala converts that
   instance to a `Function0`). This is similar to
  -the https://docs.spring.io/spring/docs/current/spring-framework-reference/html/beans.html#beans-factory-scopes-singleton[singleton scope] in spring DI.
  +the https://docs.spring.io/spring/docs/current/spring-framework-reference/html/beans.html#beans-factory-scopes-singleton[singleton scope] in Spring dependency injection.
   
   However, since this is a normal scala function, you can write whatever
   you want within that function. For ex. as the `sequenceNumberService`
  
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's clear what's happening.
  
  Calling `DependencyFactory.sequenceNumberService.vend` will return a
  new number every time, since that's how it's 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's 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: . https://liftweb.net/api/26/api/index.html#net.liftweb.util.SimpleInjector$Inject[`Inject`], an abstract class within the
   `SimpleInjector` trait.
  
  `FactoryMaker` and `Inject` serve the same purpose, with the former
  having more features. The difference is important. Notes on this are
  at the end. I'll continue with `FactoryMaker` for the sake of
  examples, and then note the differences between the two at the end.
  