anchor.diff:  
   You can write your own `RequestPredicate`, but the `RequestPredicates` utility class
   offers commonly used implementations, based on the request path, HTTP method, content-type,
  -and so on. The following example creates a request predicate based on a path:
  -
  -====
  -[source,java,indent=0]
  -[subs="verbatim,quotes"]
  -----
  -RouterFunction<ServerResponse> route =
  -	RouterFunctions.route(RequestPredicates.path("/hello-world"),
  -	request -> Response.ok().body(fromObject("Hello World")));
  +and so on.
  +The following example uses a request predicate to create a constraint based on the `Accept`
  +header:
  +
  +====
  +[source,java,indent=0]
  +[subs="verbatim,quotes"]
  +----
  +RouterFunction<ServerResponse> route = RouterFunctions.route()
  +	.GET("/hello-world", accept(MediaType.TEXT_PLAIN),
  +		request -> Response.ok().body(fromObject("Hello World")));
   ----
   ====
   
  
positive.code: 
  
  [[webflux-fn-handler-filter-function]]
  == `HandlerFilterFunction`
  
  You can filter routes mapped by a router function by calling
  `RouterFunction.filter(HandlerFilterFunction)`, where `HandlerFilterFunction` is essentially a
  function that takes a `ServerRequest` and `HandlerFunction` and returns a `ServerResponse`.
  The handler function parameter represents the next element in the chain. This is typically the
  `HandlerFunction` that is routed to, but it can also be another `FilterFunction` if multiple filters
  are applied.
  With annotations, you can achieve similar functionality by using `@ControllerAdvice`, a `ServletFilter`, or both.
  Now we can add a simple security filter to our route, assuming that we have a `SecurityManager` that
  can determine whether a particular path is allowed. The following example shows how to do so:
  
  ====
  [source,java,indent=0]
  [subs="verbatim,quotes"]
  ----
  import static org.springframework.http.HttpStatus.UNAUTHORIZED;
  
  SecurityManager securityManager = ...
  RouterFunction<ServerResponse> route = ...
  
  RouterFunction<ServerResponse> filteredRoute =
  	route.filter((request, next) -> {
  		if (securityManager.allowAccessTo(request.path())) {
  			return next.handle(request);
  		}
  		else {
  			return ServerResponse.status(UNAUTHORIZED).build();
  		}
    });
  ----
  ====
  
  The preceding example demonstrates that invoking the `next.handle(ServerRequest)` is optional. We
  allow only the handler function to be executed when access is allowed.
  
  NOTE: CORS support for functional endpoints is provided through a dedicated <<webflux-cors-webfilter,`CorsWebFilter`>>.
  
negative.code: [[webflux-fn-overview]]
  == Overview
  
  In WebFlux.fn, an HTTP request is handled with a `HandlerFunction`: a function that takes
  `ServerRequest` and returns a delayed `ServerResponse` (i.e. `Mono<ServerResponse>`).
  Both the request as the response object have immutable contracts that offer JDK 8-friendly
  access to the HTTP request and response.
  `HandlerFunction` is the equivalent of the body of a `@RequestMapping` method in the
  annotation-based programming model.
  
  Incoming requests are routed to a handler function with a `RouterFunction`: a function that
  takes `ServerRequest` and returns a delayed `HandlerFunction` (i.e. `Mono<HandlerFunction>`).
  When the router function matches, a handler function is returned; otherwise an empty Mono.
  `RouterFunction` is the equivalent of a `@RequestMapping` annotation, but with the major
  difference that router functions provide not just data, but also behavior.
  
  `RouterFunctions.route()` provides a router builder that facilitates the creation of routers,
  as the following example shows:
  
  ====
  