anchor.diff:      // declare Controller as single instance, resolving View instance with get()
       single<Controller> { create<ControllerImpl>() }
   }
  -----
  -
  -=== Declaring injection parameters
  -
  -In any `single` or `factory` definition, you can use injection parameters: parameters that will be injected and used by your definition:
  -
  -[source,kotlin]
  -----
  -class Presenter(val view : View)
  -
  -val myModule = module {
  -    single{ (view : View) -> Presenter(view) }
  -}
  -----
  -
  -In contrary to resolved dependencies (resolved with with `get()`), injection parameters are *parameters passed through the resolution API*.
  -This means that those parameters are values passed with `get()` and `by inject()`, with the `parametersOf` function:
  -
  -
  -[source,kotlin]
  -----
  -val presenter : Presenter by inject { parametersOf(view) }
  -----
  -
  -Further reading in the <<injection-parameters.adoc#_injection_parameters,injection parameters section>>.
  -
  -=== Conflicting definitions
  -
  -Conflicting definitions occurs when you have:
  -
  -* several definitions that are matching the same type
  -* defined a circular dependency
  -
  -In the first case, you can name your definition to distinguish them. You can also use modules to alter resolution visibility. In last case, you can also specify a module path when you request a dependency from a KoinComponent.
  -
  -[source,kotlin]
  -----
  -val myModule = module("org.sample") {
  -
  -
  -    module("org.demo"){
  -        single<Service>{ ServiceImpl() }
  -    }
  -
  -    module("org.sample"){
  -        single<Service>{ ServiceImpl() }
  -    }
  -}
  -
  -// Request dependency from /org/sample namespace
  -val service : Service by inject(module = "org.sample")
  -----
  -
  -For a circular dependency problem, you are in the situation where `A<-B` & `B<-A`. You have to review your relation between A & B, and break the circularity  to resolve your situation.
  -
  -
  -=== Definition flags
  -
  -Koin DSL also proposes some flags.
  -
  -==== Create instances at start
  -
  -A definition or a module can be flagged as `createOnStart`, to be created at start (or when you want). First set the `createOnStart` flag on your module
  -or on your definition.
  -
  -
  -.CreateOnStart flag at definition level
  -[source,kotlin]
  -----
  -val myModuleA = module {
  -
  -    single<Service> { ServiceImp() }
  -}
  -
  -val myModuleB = module {
  -
  -    // eager creation for this definition
  -    single<Service>(createOnStart=true) { TestServiceImp() }
  -}
  -----
  -
  -.CreateOnStart flag at module level
  -[source,kotlin]
  -----
  -val myModuleA = module {
  -
  -    single<Service> { ServiceImp() }
  -}
  -
  -val myModuleB = module(createOnStart=true) {
  -
  -    single<Service>{ TestServiceImp() }
  -}
  -----
  -
  -The `startKoin` function will automatically create definition instances flagged with `createOnStart`.
  -
  -[source,kotlin]
  -----
  -// Start Koin modules
  -startKoin(listOf(myModuleA,myModuleB))
  -----
  -
  -If you don't want to create instances at start, jus use the `createOnStart` at false from the `startKoin()` function:
  -
  -[source,kotlin]
  -----
  -// Start Koin modules
  -startKoin(listOf(myModuleA,myModuleB), createOnStart = false)
  -----
  -
  -[NOTE]
  -====
  -if you need to load some definition at a special time (in a background thread instead of UI for example), just get/inject the desired components.
  -====
  -
  -==== Overriding a definition or a module
  -
  -Koin won't allow you to redefinition an already existing definition (type,name,path ...). You will an an error if you try this:
  -
  -.Override not allowed
  -[source,kotlin]
  -----
  -val myModuleA = module {
  -
  -    single<Service> { ServiceImp() }
  -}
  -
  -val myModuleB = module {
  -
  -    single<Service> { TestServiceImp() }
  -}
  -
  -// Will throw an BeanOverrideException
  -startKoin(listOf(myModuleA,myModuleB))
  -----
  -
  -To allow definition overriding, you have to use the `override` parameter:
  -
  -.Override at definition level
  -[source,kotlin]
  -----
  -val myModuleA = module {
  -
  -    single<Service> { ServiceImp() }
  -}
  -
  -val myModuleB = module {
  -
  -    // override for this definition
  -    single<Service>(override=true) { TestServiceImp() }
  -}
  -----
  -
  -.Override at module level
  -[source,kotlin]
  -----
  -val myModuleA = module {
  -
  -    single<Service> { ServiceImp() }
  -}
  -
  -// Allow override for all definitions from module
  -val myModuleB = module(override=true) {
  -
  -    single<Service> { TestServiceImp() }
  -}
  -----
  -
  -[IMPORTANT]
  -====
  -Order matters when listing modules and overriding definitions. You must have your overriding definitions in last of your module list.
  -====+----
positive.code: * `module` - create a Koin Module
  * `factory` - provide a factory bean definition
  * `single` - provide a singleton bean definition (also aliased as `bean`)
  * `bind` - add type to bind for given bean definition
  * `get` - resolve a component dependency
  * `create` - create an instance of given type, by injecting its constructor with dependencies
  
  === Writing a module
  
  
negative.code: 
  `get()` and `by inject()` functions let you specify a definition name if needed.
  
  === Declaring injection parameters
  
  In any `single` or `factory` definition, you can use injection parameters: parameters that will be injected and used by your definition:
  
  [source,kotlin]
  ----
  class Presenter(val view : View)
  
  val myModule = module {
      single{ (view : View) -> Presenter(view) }
  }
  ----
  
  In contrary to resolved dependencies (resolved with with `get()`), injection parameters are *parameters passed through the resolution API*.
  This means that those parameters are values passed with `get()` and `by inject()`, with the `parametersOf` function:
  
  
  [source,kotlin]
  ----
  val presenter : Presenter by inject { parametersOf(view) }
  ----
  
  Further reading in the <<injection-parameters.adoc#_injection_parameters,injection parameters section>>.
  
  === Conflicting definitions
  
  Conflicting definitions occurs when you have:
  
  * several definitions that are matching the same type
  * defined a circular dependency
  
  In the first case, you can name your definition to distinguish them. You can also use modules to alter resolution visibility. In last case, you can also specify a module path when you request a dependency from a KoinComponent.
  
  [source,kotlin]
  ----
  val myModule = module("org.sample") {
  
  
      module("org.demo"){
          single<Service>{ ServiceImpl() }
      }
  
      module("org.sample"){
          single<Service>{ ServiceImpl() }
      }
  }
  
  // Request dependency from /org/sample namespace
  val service : Service by inject(module = "org.sample")
  ----
  
  For a circular dependency problem, you are in the situation where `A<-B` & `B<-A`. You have to review your relation between A & B, and break the circularity  to resolve your situation.
  
  
  === Definition flags
  
  Koin DSL also proposes some flags.
  
  ==== Create instances at start
  
  A definition or a module can be flagged as `createOnStart`, to be created at start (or when you want). First set the `createOnStart` flag on your module
  or on your definition.
  
  
  .CreateOnStart flag at definition level
  [source,kotlin]
  ----
  val myModuleA = module {
  
      single<Service> { ServiceImp() }
  }
  
  val myModuleB = module {
  
      // eager creation for this definition
      single<Service>(createOnStart=true) { TestServiceImp() }
  }
  ----
  
  .CreateOnStart flag at module level
  [source,kotlin]
  ----
  val myModuleA = module {
  
      single<Service> { ServiceImp() }
  }
  
  val myModuleB = module(createOnStart=true) {
  
      single<Service>{ TestServiceImp() }
  }
  ----
  
  The `startKoin` function will automatically create definition instances flagged with `createOnStart`.
  
  [source,kotlin]
  ----
  // Start Koin modules
  startKoin(listOf(myModuleA,myModuleB))
  ----
  
  If you don't want to create instances at start, jus use the `createOnStart` at false from the `startKoin()` function:
  
  [source,kotlin]
  ----
  // Start Koin modules
  startKoin(listOf(myModuleA,myModuleB), createOnStart = false)
  ----
  
  [NOTE]
  ====
  if you need to load some definition at a special time (in a background thread instead of UI for example), just get/inject the desired components.
  ====
  
  ==== Overriding a definition or a module
  
  Koin won't allow you to redefinition an already existing definition (type,name,path ...). You will an an error if you try this:
  
  .Override not allowed
  [source,kotlin]
  ----
  val myModuleA = module {
  
      single<Service> { ServiceImp() }
  }
  
  val myModuleB = module {
  
      single<Service> { TestServiceImp() }
  }
  
  // Will throw an BeanOverrideException
  startKoin(listOf(myModuleA,myModuleB))
  ----
  
  To allow definition overriding, you have to use the `override` parameter:
  
  .Override at definition level
  [source,kotlin]
  ----
  val myModuleA = module {
  
      single<Service> { ServiceImp() }
  }
  
  val myModuleB = module {
  
      // override for this definition
      single<Service>(override=true) { TestServiceImp() }
  }
  ----
  
  .Override at module level
  [source,kotlin]
  ----
  val myModuleA = module {
  
      single<Service> { ServiceImp() }
  }
  
  // Allow override for all definitions from module
  val myModuleB = module(override=true) {
  
      single<Service> { TestServiceImp() }
  }
  ----
  
  [IMPORTANT]
  ====
  Order matters when listing modules and overriding definitions. You must have your overriding definitions in last of your module list.
  ====
  
  
  ==== Dealing with generics
  
  Koin definitions doesn't take in accounts generics type argument. For example, the module below tries to define 2 definitions of List:
  
  [source,kotlin]
  ----
  module {
      single { ArrayList<Int>() }
      single { ArrayList<String>() }
  }
  ----
  
  Koin won't start with such definitions, understanding that you want to override one definition for the other.
  
  To allow you, use the 2 definitions you will have to differentiate them via their name, or location (module). For example:
  
  [source,kotlin]
  ----
  module {
      single(name="Ints") { ArrayList<Int>() }
      single(name="Strings") { ArrayList<String>() }
  }
  ----
  
  === Experimental features
  
  ==== Create instances using the create() function
  
  Koin has the `create<T>()` function that allows you to create an instance of type `T` and inject its first constructor.
  Note that if you don"t provide any definition lambda to your single/factory definition, will be able to create it for you:
  