Corrects some typos in docs

docs/modules/ROOT/pages/spring-cloud-function/deploying-a-packaged.adoc

@@ -19,7 +19,7 @@ the functions. It can optionally use a `maven:` prefix to locate the artifact vi
 for complete details). A Spring Boot application is bootstrapped from the jar file, using the `MANIFEST.MF` to locate a start class, so
 that a standard Spring Boot fat jar works well, for example. If the target jar can be launched successfully then the result is a function
 registered in the main application's `FunctionCatalog`. The registered function can be applied by code in the main application, even though
-it was created in an isolated class loader (by deault).
+it was created in an isolated class loader (by default).
 
 Here is the example of deploying a JAR which contains an 'uppercase' function and invoking it .
 

docs/modules/ROOT/pages/spring-cloud-function/programming-model.adoc

@@ -55,13 +55,13 @@ Function uppercase =  catalog.lookup(“uppercase”);
 ----
 
 Important to understand that given that `uppercase` is a bean, you can certainly get it form the `ApplicationContext` directly, but all you will get is just your bean as you declared it without any extra features provided by SCF. When you do lookup of a function via `FunctionCatalog`, the instance you will receive is wrapped (instrumented) with additional features (i.e., type conversion, composition etc.) described in this manual. Also, it is important to understand that a typical user does not use Spring Cloud Function directly. Instead a typical user implements Java `Function/Supplier/Consumer` with the idea of using it in different execution contexts without additional work. For example the same java function could be represented as _REST endpoint_ or _Streaming message handler_ or _AWS Lambda_ and more via Spring Cloud Function provided
-adapters as well as other frameworks using Spring Cloud Function as the core programming model (e.g., https://spring.io/projects/spring-cloud-stream[Spring Cloud Stream])
+adapters as well as other frameworks using Spring Cloud Function as the core programming model (e.g., https://spring.io/projects/spring-cloud-stream[Spring Cloud Stream]).
 So in summary Spring Cloud Function instruments java functions with additional features to be utilised in variety of execution contexts.
 
 
 [[function-definition]]
 === Function definition
-While the previous example shows you how to lookup function in FunctionCatalog programmatically, in a typical integration case where Spring Cloud Function used as programming model by another framework (e.fg. Spring Cloud Stream), you declare which functions to use via `spring.cloud.function.definition` property. Knowing that it is  important to understand some default behaviour when it comes to discovering functions in `FunctionCatalog`. For example, if you only have one Functional bean in your `ApplicationContext`,  the `spring.cloud.function.definition` property typically will not be required, since a single function in `FunctionCatalog` can be looked up by an empty name or any name. For example, assuming that `uppercase` is the only function in your catalog, it can be looked up as `catalog.lookup(null)`, `catalog.lookup(“”)`, `catalog.lookup(“foo”)`
+While the previous example shows you how to lookup function in FunctionCatalog programmatically, in a typical integration case where Spring Cloud Function used as programming model by another framework (e.g., https://spring.io/projects/spring-cloud-stream[Spring Cloud Stream]), you declare which functions to use via `spring.cloud.function.definition` property. Knowing that it is  important to understand some default behaviour when it comes to discovering functions in `FunctionCatalog`. For example, if you only have one Functional bean in your `ApplicationContext`,  the `spring.cloud.function.definition` property typically will not be required, since a single function in `FunctionCatalog` can be looked up by an empty name or any name. For example, assuming that `uppercase` is the only function in your catalog, it can be looked up as `catalog.lookup(null)`, `catalog.lookup(“”)`, `catalog.lookup(“foo”)`.
 That said, for cases where you are using framework such as Spring Cloud Stream which uses `spring.cloud.function.definition` it is best practice and recommended to always use `spring.cloud.function.definition` property.
 
 For example,
@@ -169,7 +169,7 @@ And of course you can't compose uncomposable such as Consumer and Function, Cons
 == Function Routing and Filtering
 
 Since version 2.2 Spring Cloud Function provides routing feature allowing
-you to invoke a single function which acts as a router to an actual function you wish to invoke
+you to invoke a single function which acts as a router to an actual function you wish to invoke.
 This feature is very useful in certain FAAS environments where maintaining configurations
 for several functions could be cumbersome or exposing more than one function is not possible.
 

docs/modules/ROOT/pages/spring-cloud-function/standalone-web-applications.adoc

@@ -46,7 +46,7 @@ See <<Testing Functional Applications>> to see the details and example on how to
 As you have noticed from the previous table, you can pass an argument to a function as path variable (i.e., `/\{function}/\{item}`).
 For example, `http://localhost:8080/uppercase/foo` will result in calling `uppercase` function with its input parameter being `foo`.
 
-While this is the recommended approach and the one that fits most use cases cases, there are times when you have to deal with HTTP request parameters (e.g., `http://localhost:8080/uppercase/foo?name=Bill`)
+While this is the recommended approach and the one that fits most use cases cases, there are times when you have to deal with HTTP request parameters (e.g., `http://localhost:8080/uppercase/foo?name=Bill`).
 The framework will treat HTTP request parameters similar to the HTTP headers by storing them in the `Message` headers under the header key `http_request_param`
 with its value being a `Map` of request parameters, so in order to access them your function input signature should accept `Message` type (e.g., `Function<Message<String>, String>`). For convenience we provide `HeaderUtils.HTTP_REQUEST_PARAM` constant.
 
@@ -82,7 +82,7 @@ of the actual URL, giving user ability to use it for evaluation and computation.
 
 In situations where there are more than one function in catalog there may be a need to only export certain functions or function compositions. In that case you can use
 the same `spring.cloud.function.definition` property listing functions you intend to export delimited by `;`.
-Note that in this case nothing will be mapped to the root path and functions that are not listed (including compositions) are not going to be exported
+Note that in this case nothing will be mapped to the root path and functions that are not listed (including compositions) are not going to be exported.
 
 For example,
 
@@ -101,7 +101,7 @@ This will only export function composition `foo|bar` and function `baz` regardle
 == Http Headers propagation
 
 By default most request `HttpHeaders` are copied into the response `HttpHeaders`. If you require to filter out certain headers you can provide the names of those headers using  
-`spring.cloud.function.http.ignored-headers` delimited by comas. For example, `spring.cloud.function.http.ignored-headers=foo,bar`
+`spring.cloud.function.http.ignored-headers` delimited by comas. For example, `spring.cloud.function.http.ignored-headers=foo,bar`.
 
 [[crud-rest-with-spring-cloud-function]]
 == CRUD REST with Spring Cloud Function