anchor.diff:  
   [source,java]
   ----
  -@Bulkhead(name = "backendA", recovery = MyRecoveryFunction.class)
  +@Bulkhead(name = "backendA", fallbackMethod = "fallback")
   @Singleton
   public class BackendAConnector implements Connector {
       ...
   }
   ----
  -Where `MyRecoveryFunction` is implements `io.github.resilience4j.ratpack.RecoveryFunction` and provides
  +Where `fallbackMethod` is a method in the same class that provides
   a fallback value that is returned when the bulkhead identified by `name` is full or call ends in exception.
   
   
  
positive.code: 
  [source,java]
  ----
  @RateLimiter(name = "backendA", recovery = MyRecoveryFunction.class)
  @Singleton
  public class BackendAConnector implements Connector {
      ...
  }
  ----
  Where `MyRecoveryFunction` is implements `io.github.resilience4j.ratpack.RecoveryFunction` and provides
  a fallback value that is returned when the rate limiter rate limit identified by `name` is exceeded.
  
  ==== Functional style
  
negative.code: 
  * Promise
  * CompletionStage
  * Object
  * Flux
  * Mono
  
  ===== A Note About Fallback Methods
  
  The `fallbackMethod` parameter signature for the annotations listed in the next sections must match either:
  
  1) The method parameter signature on the annotated method or
  2) The method parameter signature with a matching exception type as the last parameter on the annotated method
  
  The return value can be a https://ratpack.io/manual/current/api/ratpack/exec/Promise.html[Promise],
  https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/CompletionStage.html[CompletionStage],
  https://projectreactor.io/docs/core/release/api/reactor/core/publisher/Flux.html[Flux],
  https://projectreactor.io/docs/core/release/api/reactor/core/publisher/Mono.html[Mono], or any non-reactive object type.
  Other reactive types are not supported.
  
  If the return value is one of the reactive types listed above, it must match the return value type of the annotated method.
  
  ====== Examples
  
  Fallback for a no-params method
  [source,java]
  ----
  String fallback() {
      "recovered"
  }
  
  OR
  
  String fallback(Throwable throwable) {
      "recovered"
  }
  ----
  
  Fallback for a method with a single `String` parameter
  [source,java]
  ----
  String fallback(String s) {
      "recovered"
  }
  
  OR
  
  String fallback(String s, Throwable throwable) {
      "recovered"
  }
  ----
  
  `Promise` fallback
  [source,java]
  ----
  Promise<String> fallback(String s, Throwable throwable) {
      Promise.value("recovered")
  }
  ----
  
  `CompletionStage` fallback
  [source,java]
  ----
  CompletionStage<String> fallback(String s, Throwable throwable) {
      def future = new CompletableFuture<String>()
      future.complete("recovered")
      return future
  }
  ----
  
  `Flux` fallback
  [source,java]
  ----
  Flux<String> fallback(String s, Throwable throwable) {
      Flux.just("recovered")
  }
  ----
  
  `Mono` fallback
  [source,java]
  ----
  Mono<String> fallback(String s, Throwable throwable) {
      Mono.just("recovered")
  }
  ----
  
  ===== Bulkhead
  The demo shows how to use the `Bulkhead` annotation to have your Ratpack application limiting number of method calls.
  