anchor.diff:    to the "Hero of the Month" contest.
   
     The local state is the number `2`, the number of runners-up this component should show.
  -  We execute `runnersUpFactory` immediately with `2`.
  +  It executes `runnersUpFactory` immediately with `2`.
   
     The `runnersUpFactory` itself isn't the provider factory function.
     The true provider factory function is the function that `runnersUpFactory` returns.
  
positive.code:   ## Application-wide dependencies
    Register providers for dependencies used throughout the application in the root application component, `AppComponent`.
  
    In the following example, we import and register several services
    (the `LoggerService`, `UserContext`, and the `UserService`)
    in the `@Component` metadata `providers` array.
  
  +makeExample('cb-dependency-injection/ts/src/app/app.component.ts','import-services','src/app/app.component.ts (excerpt)')(format='.')
  :marked
    All of these services are implemented as classes.
    Service classes can act as their own providers which is why listing them in the `providers` array
    is all the registration we need.
  .l-sub-section
    :marked
      A *provider* is something that can create or deliver a service.
      Angular creates a service instance from a class provider by "new-ing" it.
      Learn more about providers [below](#providers).
  :marked
    Now that we've registered these services,
    Angular can inject them into the constructor of *any* component or service, *anywhere* in the application.
  +makeExample('cb-dependency-injection/ts/src/app/hero-bios.component.ts','ctor','src/app/hero-bios.component.ts (component constructor injection)')(format='.')
  
  
negative.code: .l-sub-section
    :marked
      #### Why *MinimalLogger* is a class and not an interface
      You can't use an interface as a provider token because
      interfaces are not JavaScript objects.
      They exist only in the TypeScript design space.
      They disappear after the code is transpiled to JavaScript.
  
      A provider token must be a real JavaScript object of some kind:
      such as a function, an object, a string, or a class.
  
      Using a class as an interface gives you the characteristics of an interface in a JavaScript object.
  
      To minimize memory cost, the class should have *no implementation*.
      The `MinimalLogger` transpiles to this unoptimized, pre-minified JavaScript:
    +makeExample('cb-dependency-injection/ts/src/app/date-logger.service.ts','minimal-logger-transpiled')(format='.')
    :marked
       It never grows larger no matter how many members you add *as long as they are typed but not implemented*.
  
  a(id='opaque-token')
  :marked
    ### _OpaqueToken_
  
    Dependency objects can be simple values like dates, numbers and strings, or
    shapeless objects like arrays and functions.
  
    Such objects don't have application interfaces and therefore aren't well represented by a class.
  