anchor.diff:  Make sure to https://github.com/sdeleuze/spring-kotlin-functional/blob/2d6ac07adfc2b8f25e91681dbb2b58a1c6cdf9a7/build.gradle.kts#L57[include JSR-305 JAR]
   until Kotlin 1.1.5 is released (it will fix https://youtrack.jetbrains.com/issue/KT-19419[KT-19419]).
   
  -Currently null-safety does not apply to generic type parameters, but that could change in
  -the future, the related issue is https://youtrack.jetbrains.com/issue/KT-19592[KT-19592].
  -
   [NOTE]
   ====
   Other libraries like Reactor or Spring Data leverage these annotations to provide
  
positive.code: }
  ----
  
  In order to allow a more declarative approach and cleaner syntax, Spring Framework 5 introduces
  a new {doc-root}/spring-framework/docs/{spring-version}/kdoc-api/spring-framework/org.springframework.context.support/-bean-definition-dsl/[Kotlin bean definition DSL]
  It declares an `ApplicationContextInitializer` via a clean declarative API which allows
  you to deal with profiles and `Environment` for customizing how your beans are registered.
  
  
negative.code: If you are using Spring Boot, you would probably be interested in using
  https://docs.spring.io/spring-boot/docs/current/reference/html/boot-features-external-config.html#boot-features-external-config-typesafe-configuration-properties[`@ConfigurationProperties`]
  instead of `@Value`, but currently you have to use it with nullable `var` (which is far from ideal)
  properties since immutable classes initialized by constructor are not supported yet.
  See these issues about https://github.com/spring-projects/spring-boot/issues/8762[`@ConfigurationProperties` binding for immutable POJOs]
  and https://github.com/spring-projects/spring-boot/issues/1254[`@ConfigurationProperties` binding on interfaces]
  for more details.
  ====
  
  === Annotation array attributes
  
  Kotlin annotations are mostly similar to Java ones, but array attributes - which are
  extensively used in Spring - behaves differently. As explained in https://kotlinlang.org/docs/reference/annotations.html[Kotlin documentation]
  unlike other attributes, `value` attribute name can be omitted and when it is an array
  attribute it is specified as a `vararg` parameter.
  
  To understand what that means more concretely, let's take `@RequestMapping`, which is one
  of the most used Spring annotation as an example. This Java annotation is declared as following:
  
  [source,java]
  ----
  public @interface RequestMapping {
  
    @AliasFor("path")
    String[] value() default {};
  
    @AliasFor("value")
    String[] path() default {};
  
    RequestMethod[] method() default {};
  
    // ...
  }
  ----
  
  The typical use case for `@RequestMapping` is to map an handler method to a specific path
  + method. In Java, it is possible to specify single value for annotation array attribute,
  they will be automatically converted to arrays. That's why you can write
  `@RequestMapping(value = "/foo", method = RequestMethod.GET)` or
  `@RequestMapping(path = "/foo", method = RequestMethod.GET)`.
  
  In Kotlin, you will have to write `@RequestMapping("/foo", method = arrayOf(RequestMethod.GET))`.
  The variant using `path` is not recommended as it need to be written
  `@RequestMapping(path = arrayOf("/foo"), method = arrayOf(RequestMethod.GET))`.
  
  A workaround for this specific `method` attribute (the most common one)  is to use shortcut
  annotation like `@GetMapping`, `@PostMapping`, etc.
  
  [NOTE]
  ====
  Remininder: if you don't specify `@RequestMapping` `method` attribute, all HTTP methods will be matched,
  not just `GET` ones.
  ====
  
  Improving syntax and consistency of Kotlin annotation array attributes is discussed in
  https://youtrack.jetbrains.com/issue/KT-11235[this Kotlin language design issue].
  
  === Testing
  
  