anchor.diff:  }
   ```
   
  -It would also work if you add a separate, standalone class of type `Function` and register it with the `SpringApplication` using an alternative form of the `run()` method. The main thing is that the generic type information is available at runtime through the class declaration.
  -
  -The app runs in its own HTTP server if you add `spring-cloud-starter-function-webflux` (it won't work with the MVC starter at the moment because the functional form of the embedded Servlet container hasn't been implemented).  The app also runs just fine in AWS Lambda or Azure Functions, and the improvements in startup time are dramatic.
  -
  -NOTE: The "lite" web server has some limitations for the range of `Function` signatures - in particular it doesn't (yet) support `Message` input and output, but POJOs and any kind of `Publisher` should be fine.
  +It would also work if you add a separate, standalone class of type `Function` and register it with
  +the `SpringApplication` using an alternative form of the `run()` method. The main thing is that the generic
  +type information is available at runtime through the class declaration.
  +
  +Suppose you have
  +[source, java]
  +----
  +@Component
  +public class CustomFunction implements Function<Flux<Foo>, Flux<Bar>> {
  +	@Override
  +	public Flux<Bar> apply(Flux<Foo> flux) {
  +		return flux.map(foo -> new Bar("This is a Bar object from Foo value: " + foo.getValue()));
  +	}
  +
  +}
  +----
  +
  +You register it as such:
  +
  +[source, java]
  +----
  +@Override
  +public void initialize(GenericApplicationContext context) {
  +		context.registerBean("function", FunctionRegistration.class,
  +				() -> new FunctionRegistration<>(new CustomFunction()).type(CustomFunction.class));
  +}
  +----
   
   == Limitations of Functional Bean Declaration
   
  
positive.code: `FunctionalSpringApplication` from Spring Cloud Function (it's a
  subclass).
  
  The business logic beans that you register in a Spring Cloud Function app are of type `FunctionRegistration`. This is a wrapper that contains both the function and information about the input and output types. In the `@Bean` form of the application that information can be derived reflectively, but in a functional bean registration some of it is lost unless we use a `FunctionRegistration`.
  
  An alternative to using an `ApplicationContextInitializer` and `FunctionRegistration` is to make the application itself implement `Function` (or `Consumer` or `Supplier`). Example (equivalent to the above):
  
  ```java
  @SpringBootConfiguration
  
negative.code: 
  }
  ```
  
  Now for the functional beans: the user application code can be recast into "functional"
  form, like this:
  