anchor.diff:  that can provide DI by composing traits.
   
   Although the cake pattern is helpful, it doesn't provide complete DI functionality.
  -The cake pattern allows you to compose complex classes out of Scala traits, but the it's less helpful
  +The cake pattern allows you to compose complex classes out of Scala traits, but it is less helpful
   in terms of allowing you to make dynamic choices about which combination of cake to vend in a given situation.
   Lift provides extra features that complete the dependency injection puzzle.
   
  -== Why Lift DI
  -
  -Many people come to Scala from a Java background, so it's only natural to want to use Guice/Spring,
  +== Why Lift Dependency Injection
  +
  +Many people come to Scala from a Java background, so it is only natural to want to use Guice/Spring,
   which do a great job in the java world. And we can https://groups.google.com/forum/#!topic/liftweb/_lleL2xpCFU[use those],
  -but there's a better, more direct way that's less magical.
  +but there's a better, more direct way that is less magical.
   
   Lift's philosophy is to keep things as simple as possible (and no simpler), and allow full control
   to the developers over how things work. To paraphrase David Pollak,
  -"The abstraction turtles have to end somewhere" and  lift's DI features end those turtles quite
  +"The abstraction turtles have to end somewhere" and  Lift's Dependency Injection features end those turtles quite
   early.
   
  -== Lift DI and various dependency scopes (e.g. from Spring)
  -
  -Lift's DI allows all the
  +== Lift's dependency injection and various dependency scopes (e.g. from Spring)
  +
  +Lift's dependency injection allows all the
   https://docs.spring.io/spring/docs/current/spring-framework-reference/html/beans.html#beans-factory-scopes[four most commonly used scopes] that
   are possible with spring:
   https://docs.spring.io/spring/docs/current/spring-framework-reference/html/beans.html#beans-factory-scopes-singleton[singleton],
  
positive.code: . https://liftweb.net/api/26/api/index.html#net.liftweb.util.SimpleInjector$Inject[`Inject`], an abstract class within the
   `SimpleInjector` trait.
  
  `FactoryMaker` and `Injector` 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.
  
negative.code: 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 dependency injection.
  
  However, since this is a normal scala function, you can write whatever
  you want within that function. For ex. as the `sequenceNumberService`
  