anchor.diff:  
   `get()` and `by inject()` functions let you specify a definition name if needed.
   
  -=== Create instances using the create() function
  +=== 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:
  
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:     // declare Controller as single instance, resolving View instance with get()
      single<Controller> { create<ControllerImpl>() }
  }
  ----