anchor.diff:  
   * Promise
   * CompletionStage
  -* object values
  -* Observable
  -* Flowable
  -* Single
  +* 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.
  
positive.code: 
  [source,java]
  ----
  @CircuitBreaker(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 circuit breaker identified by `name` is open.
  
  ===== Retry
  
negative.code: `
  [source,java]
  ----
  @Retry(name = "backendA", fallbackMethod = "fallback")
  @Singleton
  public class BackendAConnector implements Connector {
      ...
  }
  ----
  Where `fallbackMethod` is a method in the same class that provides
  a fallback value that is returned when the retry identified by `name` is has exceeded it's max calls.
  
  ===== RateLimiter
  