From 289576ab91b668ca69d816887e28c9ae23b8d527 Mon Sep 17 00:00:00 2001
From: buildmaster <buildmaster@springframework.org>
Date: Fri, 22 Nov 2019 11:55:16 +0000
Subject: [PATCH] Sync docs from master to gh-pages

---
 reference/html/README.html                |  33 ----
 reference/html/aws.html                   |   4 +-
 reference/html/azure.html                 |   2 +-
 reference/html/getting-started.html       |  42 +----
 reference/html/index.html                 |   2 +-
 reference/html/openwhisk.html             |   2 +-
 reference/html/spring-cloud-function.html | 220 ++++++++++------------
 7 files changed, 105 insertions(+), 200 deletions(-)

diff --git a/reference/html/README.html b/reference/html/README.html
index 409d9bbf9..f52cd1e3a 100644
--- a/reference/html/README.html
+++ b/reference/html/README.html
@@ -97,7 +97,6 @@ $(addBlockSwitches);
 <ul class="sectlevel1">
 <li><a href="#_introduction">Introduction</a></li>
 <li><a href="#_getting_started">Getting Started</a></li>
-<li><a href="#_building_and_running_a_function">Building and Running a Function</a></li>
 <li><a href="#_building">Building</a>
 <ul class="sectlevel2">
 <li><a href="#_basic_compile_and_test">Basic Compile and Test</a></li>
@@ -274,38 +273,6 @@ string like that.)</p>
 </div>
 </div>
 <div class="sect1">
-<h2 id="_building_and_running_a_function"><a class="link" href="#_building_and_running_a_function">Building and Running a Function</a></h2>
-<div class="sectionbody">
-<div class="paragraph">
-<p>The sample <code>@SpringBootApplication</code> above has a function that can be
-decorated at runtime by Spring Cloud Function to be an HTTP endpoint,
-or a Stream processor, for instance with RabbitMQ, Apache Kafka or
-JMS.</p>
-</div>
-<div class="paragraph">
-<p>The <code>@Beans</code> can be <code>Function</code>, <code>Consumer</code> or <code>Supplier</code> (all from
-<code>java.util</code>), and their parametric types can be String or POJO.</p>
-</div>
-<div class="paragraph">
-<p>Functions can also be of <code>Flux&lt;String&gt;</code> or <code>Flux&lt;Pojo&gt;</code> and Spring
-Cloud Function takes care of converting the data to and from the
-desired types, as long as it comes in as plain text or (in the case of
-the POJO) JSON. There is also support for <code>Message&lt;Pojo&gt;</code> where the
-message headers are copied from the incoming event, depending on the
-adapter. The web adapter also supports conversion from form-encoded
-data to a <code>Map</code>, and if you are using the function with Spring Cloud
-Stream then all the conversion and coercion features for message
-payloads will be applicable as well.</p>
-</div>
-<div class="paragraph">
-<p>Functions can be grouped together in a single application, or deployed
-one-per-jar. It&#8217;s up to the developer to choose. An app with multiple
-functions can be deployed multiple times in different "personalities",
-exposing different functions over different physical transports.</p>
-</div>
-</div>
-</div>
-<div class="sect1">
 <h2 id="_building"><a class="link" href="#_building">Building</a></h2>
 <div class="sectionbody">
 <div class="sect2">
diff --git a/reference/html/aws.html b/reference/html/aws.html
index aa60bb16e..45a5445ce 100644
--- a/reference/html/aws.html
+++ b/reference/html/aws.html
@@ -114,7 +114,7 @@ $(addBlockSwitches);
 <div id="preamble">
 <div class="sectionbody">
 <div class="paragraph">
-<p><strong>3.0.0.BUILD-SNAPSHOT</strong></p>
+<p><strong>3.0.1.BUILD-SNAPSHOT</strong></p>
 </div>
 <div class="paragraph">
 <p>The <a href="https://aws.amazon.com/">AWS</a> adapter takes a Spring Cloud Function app and converts it to a form that can run in AWS Lambda.</p>
@@ -376,7 +376,7 @@ we will not attempt any conversion and will pass the raw input directly to a fun
 <div class="paragraph">
 <p>Your functions will start much quicker if you can use functional bean definitions instead of <code>@Bean</code>. To do this make your main class
 an <code>ApplicationContextInitializer&lt;GenericApplicationContext&gt;</code> and use the <code>registerBean()</code> methods in <code>GenericApplicationContext</code> to
-create all the beans you need. You function need sto be registered as a bean of type <code>FunctionRegistration</code> so that the input and
+create all the beans you need. You function need to be registered as a bean of type <code>FunctionRegistration</code> so that the input and
 output types can be accessed by the framework. There is an example in github (the AWS sample is written in this style). It would
 look something like this:</p>
 </div>
diff --git a/reference/html/azure.html b/reference/html/azure.html
index 617c72795..70cb1ace4 100644
--- a/reference/html/azure.html
+++ b/reference/html/azure.html
@@ -103,7 +103,7 @@ $(addBlockSwitches);
 <div id="preamble">
 <div class="sectionbody">
 <div class="paragraph">
-<p><strong>3.0.0.BUILD-SNAPSHOT</strong></p>
+<p><strong>3.0.1.BUILD-SNAPSHOT</strong></p>
 </div>
 <div class="paragraph">
 <p>The <a href="https://azure.microsoft.com">Azure</a> adapter bootstraps a Spring Cloud Function context and channels function calls from the Azure framework into the user functions, using Spring Boot configuration where necessary. Azure Functions has quite a unique, but invasive programming model, involving annotations in user code that are specific to the platform. The easiest way to use it with Spring Cloud is to extend a base class and write a method in it with the <code>@FunctionName</code> annotation which delegates to a base class method.</p>
diff --git a/reference/html/getting-started.html b/reference/html/getting-started.html
index af4f675a6..d720d7422 100644
--- a/reference/html/getting-started.html
+++ b/reference/html/getting-started.html
@@ -5,7 +5,7 @@
 <!--[if IE]><meta http-equiv="X-UA-Compatible" content="IE=edge"><![endif]-->
 <meta name="viewport" content="width=device-width, initial-scale=1.0">
 <meta name="generator" content="Asciidoctor 1.5.8">
-<title>Building and Running a Function</title>
+<title>Untitled</title>
 <link rel="stylesheet" href="css/spring.css">
 <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/4.7.0/css/font-awesome.min.css">
 
@@ -90,14 +90,8 @@ $(addBlockSwitches);
 </script>
 
 </head>
-<body class="book toc2 toc-left">
+<body class="book">
 <div id="header">
-<div id="toc" class="toc2">
-<div id="toctitle">Table of Contents</div>
-<ul class="sectlevel1">
-<li><a href="#_building_and_running_a_function">Building and Running a Function</a></li>
-</ul>
-</div>
 </div>
 <div id="content">
 <div id="preamble">
@@ -148,38 +142,6 @@ string like that.)</p>
 </div>
 </div>
 </div>
-<div class="sect1">
-<h2 id="_building_and_running_a_function"><a class="link" href="#_building_and_running_a_function">Building and Running a Function</a></h2>
-<div class="sectionbody">
-<div class="paragraph">
-<p>The sample <code>@SpringBootApplication</code> above has a function that can be
-decorated at runtime by Spring Cloud Function to be an HTTP endpoint,
-or a Stream processor, for instance with RabbitMQ, Apache Kafka or
-JMS.</p>
-</div>
-<div class="paragraph">
-<p>The <code>@Beans</code> can be <code>Function</code>, <code>Consumer</code> or <code>Supplier</code> (all from
-<code>java.util</code>), and their parametric types can be String or POJO.</p>
-</div>
-<div class="paragraph">
-<p>Functions can also be of <code>Flux&lt;String&gt;</code> or <code>Flux&lt;Pojo&gt;</code> and Spring
-Cloud Function takes care of converting the data to and from the
-desired types, as long as it comes in as plain text or (in the case of
-the POJO) JSON. There is also support for <code>Message&lt;Pojo&gt;</code> where the
-message headers are copied from the incoming event, depending on the
-adapter. The web adapter also supports conversion from form-encoded
-data to a <code>Map</code>, and if you are using the function with Spring Cloud
-Stream then all the conversion and coercion features for message
-payloads will be applicable as well.</p>
-</div>
-<div class="paragraph">
-<p>Functions can be grouped together in a single application, or deployed
-one-per-jar. It&#8217;s up to the developer to choose. An app with multiple
-functions can be deployed multiple times in different "personalities",
-exposing different functions over different physical transports.</p>
-</div>
-</div>
-</div>
 </div>
 <script type="text/javascript" src="js/tocbot/tocbot.min.js"></script>
 <script type="text/javascript" src="js/toc.js"></script>
diff --git a/reference/html/index.html b/reference/html/index.html
index 31f9f16d4..203ceb846 100644
--- a/reference/html/index.html
+++ b/reference/html/index.html
@@ -102,7 +102,7 @@ $(addBlockSwitches);
 <div id="preamble">
 <div class="sectionbody">
 <div class="paragraph">
-<p><strong>3.0.0.BUILD-SNAPSHOT</strong></p>
+<p><strong>3.0.1.BUILD-SNAPSHOT</strong></p>
 </div>
 <div class="paragraph">
 <p>The reference documentation consists of the following sections:</p>
diff --git a/reference/html/openwhisk.html b/reference/html/openwhisk.html
index 347a86b78..a3d9d1ef6 100644
--- a/reference/html/openwhisk.html
+++ b/reference/html/openwhisk.html
@@ -103,7 +103,7 @@ $(addBlockSwitches);
 <div id="preamble">
 <div class="sectionbody">
 <div class="paragraph">
-<p><strong>3.0.0.BUILD-SNAPSHOT</strong></p>
+<p><strong>3.0.1.BUILD-SNAPSHOT</strong></p>
 </div>
 <div class="paragraph">
 <p>The <a href="https://openwhisk.apache.org/">OpenWhisk</a> adapter is in the form of an executable jar that can be used in a a docker image to be deployed to Openwhisk. The platform works in request-response mode, listening on port 8080 on a specific endpoint, so the adapter is a simple Spring MVC application.</p>
diff --git a/reference/html/spring-cloud-function.html b/reference/html/spring-cloud-function.html
index 9dab8e722..58399d2b2 100644
--- a/reference/html/spring-cloud-function.html
+++ b/reference/html/spring-cloud-function.html
@@ -98,14 +98,15 @@ $(addBlockSwitches);
 <ul class="sectlevel1">
 <li><a href="#_introduction">Introduction</a></li>
 <li><a href="#_getting_started">Getting Started</a></li>
-<li><a href="#_building_and_running_a_function">Building and Running a Function</a></li>
-<li><a href="#_function_catalog_and_flexible_function_signatures">Function Catalog and Flexible Function Signatures</a>
+<li><a href="#_programming_model">Programming model</a>
 <ul class="sectlevel2">
+<li><a href="#_function_catalog_and_flexible_function_signatures">Function Catalog and Flexible Function Signatures</a></li>
 <li><a href="#_java_8_function_support">Java 8 function support</a></li>
-<li><a href="#_function_component_scan">Function Component Scan</a></li>
 <li><a href="#_function_composition">Function Composition</a></li>
 <li><a href="#_function_routing">Function Routing</a></li>
+<li><a href="#_function_arity">Function Arity</a></li>
 <li><a href="#_kotlin_lambda_support">Kotlin Lambda support</a></li>
+<li><a href="#_function_component_scan">Function Component Scan</a></li>
 </ul>
 </li>
 <li><a href="#_standalone_web_applications">Standalone Web Applications</a></li>
@@ -135,7 +136,7 @@ $(addBlockSwitches);
 <p>Mark Fisher, Dave Syer, Oleg Zhurakousky, Anshul Mehra</p>
 </div>
 <div class="paragraph">
-<p><strong>3.0.0.BUILD-SNAPSHOT</strong></p>
+<p><strong>3.0.1.BUILD-SNAPSHOT</strong></p>
 </div>
 <hr>
 </div>
@@ -299,126 +300,51 @@ string like that.)</p>
 </div>
 </div>
 <div class="sect1">
-<h2 id="_building_and_running_a_function"><a class="link" href="#_building_and_running_a_function">Building and Running a Function</a></h2>
-<div class="sectionbody">
-<div class="paragraph">
-<p>The sample <code>@SpringBootApplication</code> above has a function that can be
-decorated at runtime by Spring Cloud Function to be an HTTP endpoint,
-or a Stream processor, for instance with RabbitMQ, Apache Kafka or
-JMS.</p>
-</div>
-<div class="paragraph">
-<p>The <code>@Beans</code> can be <code>Function</code>, <code>Consumer</code> or <code>Supplier</code> (all from
-<code>java.util</code>), and their parametric types can be String or POJO.</p>
-</div>
-<div class="paragraph">
-<p>Functions can also be of <code>Flux&lt;String&gt;</code> or <code>Flux&lt;Pojo&gt;</code> and Spring
-Cloud Function takes care of converting the data to and from the
-desired types, as long as it comes in as plain text or (in the case of
-the POJO) JSON. There is also support for <code>Message&lt;Pojo&gt;</code> where the
-message headers are copied from the incoming event, depending on the
-adapter. The web adapter also supports conversion from form-encoded
-data to a <code>Map</code>, and if you are using the function with Spring Cloud
-Stream then all the conversion and coercion features for message
-payloads will be applicable as well.</p>
-</div>
-<div class="paragraph">
-<p>Functions can be grouped together in a single application, or deployed
-one-per-jar. It&#8217;s up to the developer to choose. An app with multiple
-functions can be deployed multiple times in different "personalities",
-exposing different functions over different physical transports.</p>
-</div>
-</div>
-</div>
-<div class="sect1">
-<h2 id="_function_catalog_and_flexible_function_signatures"><a class="link" href="#_function_catalog_and_flexible_function_signatures">Function Catalog and Flexible Function Signatures</a></h2>
+<h2 id="_programming_model"><a class="link" href="#_programming_model">Programming model</a></h2>
 <div class="sectionbody">
+<div class="sect2">
+<h3 id="_function_catalog_and_flexible_function_signatures"><a class="link" href="#_function_catalog_and_flexible_function_signatures">Function Catalog and Flexible Function Signatures</a></h3>
 <div class="paragraph">
 <p>One of the main features of Spring Cloud Function is to adapt and support a range of type signatures for user-defined functions,
 while providing a consistent execution model.
-That&#8217;s why all user defined functions are transformed into a canonical representation by <code>FunctionCatalog</code>, using primitives
-defined by the <a href="https://projectreactor.io/">Project Reactor</a> (i.e., <code>Flux&lt;T&gt;</code> and <code>Mono&lt;T&gt;</code>).
-Users can supply a bean of type <code>Function&lt;String,String&gt;</code>, for instance, and the <code>FunctionCatalog</code> will wrap it into a
-<code>Function&lt;Flux&lt;String&gt;,Flux&lt;String&gt;&gt;</code>.</p>
-</div>
-<div class="paragraph">
-<p>Using Reactor based primitives not only helps with the canonical representation of user defined functions, but it also
-facilitates a more robust and flexible(reactive) execution model.</p>
+That&#8217;s why all user defined functions are transformed into a canonical representation by <code>FunctionCatalog</code>.</p>
 </div>
 <div class="paragraph">
 <p>While users don&#8217;t normally have to care about the <code>FunctionCatalog</code> at all, it is useful to know what
 kind of functions are supported in user code.</p>
 </div>
+<div class="paragraph">
+<p>It is also important to understand that Spring Cloud Function provides first class support for reactive API
+provided by <a href="https://projectreactor.io/">Project Reactor</a> allowing reactive primitives such as <code>Mono</code> and <code>Flux</code>
+to be used as types in user defined functions providing greater flexibility when choosing programming model for
+your function implementation.
+Reactive programming model also enables functional support for features that would be otherwise difficult to impossible to implement
+using imperative programming style. For more on this please read <a href="#_function_arity">Function Arity</a> section.</p>
+</div>
+</div>
 <div class="sect2">
 <h3 id="_java_8_function_support"><a class="link" href="#_java_8_function_support">Java 8 function support</a></h3>
 <div class="paragraph">
-<p>Generally speaking users can expect that if they write a function for
-a plain old Java type (or primitive wrapper), then the function
-catalog will wrap it to a <code>Flux</code> of the same type. If the user writes
-a function using <code>Message</code> (from spring-messaging) it will receive and
-transmit headers from any adapter that supports key-value metadata
-(e.g. HTTP headers). Here are the details.</p>
+<p>Spring Cloud Function embraces and builds on top of the 3 core functional interfaces defined by Java
+and available to us since Java 8.</p>
+</div>
+<div class="ulist">
+<ul>
+<li>
+<p>Supplier&lt;O&gt;</p>
+</li>
+<li>
+<p>Function&lt;I, O&gt;</p>
+</li>
+<li>
+<p>Consumer&lt;I&gt;</p>
+</li>
+</ul>
 </div>
-<table class="tableblock frame-all grid-all stretch">
-<colgroup>
-<col style="width: 33.3333%;">
-<col style="width: 33.3333%;">
-<col style="width: 33.3334%;">
-</colgroup>
-<thead>
-<tr>
-<th class="tableblock halign-left valign-top">User Function</th>
-<th class="tableblock halign-left valign-top">Catalog Registration</th>
-<th class="tableblock halign-left valign-top"></th>
-</tr>
-</thead>
-<tbody>
-<tr>
-<td class="tableblock halign-left valign-top"><p class="tableblock"><code>Function&lt;S,T&gt;</code></p></td>
-<td class="tableblock halign-left valign-top"><p class="tableblock"><code>Function&lt;Flux&lt;S&gt;, Flux&lt;T&gt;&gt;</code></p></td>
-<td class="tableblock halign-left valign-top"></td>
-</tr>
-<tr>
-<td class="tableblock halign-left valign-top"><p class="tableblock"><code>Function&lt;Message&lt;S&gt;,Message&lt;T&gt;&gt;</code></p></td>
-<td class="tableblock halign-left valign-top"><p class="tableblock"><code>Function&lt;Flux&lt;Message&lt;S&gt;&gt;, Flux&lt;Message&lt;T&gt;&gt;&gt;</code></p></td>
-<td class="tableblock halign-left valign-top"></td>
-</tr>
-<tr>
-<td class="tableblock halign-left valign-top"><p class="tableblock"><code>Function&lt;Flux&lt;S&gt;, Flux&lt;T&gt;&gt;</code></p></td>
-<td class="tableblock halign-left valign-top"><p class="tableblock"><code>Function&lt;Flux&lt;S&gt;, Flux&lt;T&gt;&gt;</code> (pass through)</p></td>
-<td class="tableblock halign-left valign-top"></td>
-</tr>
-<tr>
-<td class="tableblock halign-left valign-top"><p class="tableblock"><code>Supplier&lt;T&gt;</code></p></td>
-<td class="tableblock halign-left valign-top"><p class="tableblock"><code>Supplier&lt;Flux&lt;T&gt;&gt;</code></p></td>
-<td class="tableblock halign-left valign-top"></td>
-</tr>
-<tr>
-<td class="tableblock halign-left valign-top"><p class="tableblock"><code>Supplier&lt;Flux&lt;T&gt;&gt;</code></p></td>
-<td class="tableblock halign-left valign-top"><p class="tableblock"><code>Supplier&lt;Flux&lt;T&gt;&gt;</code></p></td>
-<td class="tableblock halign-left valign-top"></td>
-</tr>
-<tr>
-<td class="tableblock halign-left valign-top"><p class="tableblock"><code>Consumer&lt;T&gt;</code></p></td>
-<td class="tableblock halign-left valign-top"><p class="tableblock"><code>Function&lt;Flux&lt;T&gt;, Mono&lt;Void&gt;&gt;</code></p></td>
-<td class="tableblock halign-left valign-top"></td>
-</tr>
-<tr>
-<td class="tableblock halign-left valign-top"><p class="tableblock"><code>Consumer&lt;Message&lt;T&gt;&gt;</code></p></td>
-<td class="tableblock halign-left valign-top"><p class="tableblock"><code>Function&lt;Flux&lt;Message&lt;T&gt;&gt;, Mono&lt;Void&gt;&gt;</code></p></td>
-<td class="tableblock halign-left valign-top"></td>
-</tr>
-<tr>
-<td class="tableblock halign-left valign-top"><p class="tableblock"><code>Consumer&lt;Flux&lt;T&gt;&gt;</code></p></td>
-<td class="tableblock halign-left valign-top"><p class="tableblock"><code>Consumer&lt;Flux&lt;T&gt;&gt;</code></p></td>
-<td class="tableblock halign-left valign-top"></td>
-</tr>
-</tbody>
-</table>
 <div class="sect3">
 <h4 id="_supplier"><a class="link" href="#_supplier">Supplier</a></h4>
 <div class="paragraph">
-<p>As you can see from the table above Supplier can be <em>reactive</em> - <code>Supplier&lt;Flux&lt;T&gt;&gt;</code>
+<p>Supplier can be <em>reactive</em> - <code>Supplier&lt;Flux&lt;T&gt;&gt;</code>
 or <em>imperative</em> - <code>Supplier&lt;T&gt;</code>. From the invocation standpoint this should make no difference
 to the implementor of such Supplier. However, when used within frameworks
 (e.g., <a href="https://spring.io/projects/spring-cloud-stream">Spring Cloud Stream</a>), Suppliers, especially reactive,
@@ -477,19 +403,6 @@ a controlled way.</p>
 </div>
 </div>
 <div class="sect2">
-<h3 id="_function_component_scan"><a class="link" href="#_function_component_scan">Function Component Scan</a></h3>
-<div class="paragraph">
-<p>Spring Cloud Function will scan for implementations of <code>Function</code>,
-<code>Consumer</code> and <code>Supplier</code> in a package called <code>functions</code> if it
-exists. Using this feature you can write functions that have no
-dependencies on Spring - not even the <code>@Component</code> annotation is
-needed. If you want to use a different package, you can set
-<code>spring.cloud.function.scan.packages</code>. You can also use
-<code>spring.cloud.function.scan.enabled=false</code> to switch off the scan
-completely.</p>
-</div>
-</div>
-<div class="sect2">
 <h3 id="_function_composition"><a class="link" href="#_function_composition">Function Composition</a></h3>
 <div class="paragraph">
 <p>Function Composition is a feature that allows one to compose several functions into one.
@@ -613,6 +526,56 @@ values (e.g., Message).
 </div>
 </div>
 <div class="sect2">
+<h3 id="_function_arity"><a class="link" href="#_function_arity">Function Arity</a></h3>
+<div class="paragraph">
+<p>There are times when a stream of data needs to be categorized and organized. For example,
+consider a classic big-data use case of dealing with unorganized data containing, let’s say,
+‘orders’ and ‘invoices’, and you want each to go into a separate data store.
+This is where function arity (functions with multiple inputs and outputs) support
+comes to play.</p>
+</div>
+<div class="paragraph">
+<p>Let’s look at an example of such a function (full implementation details are available
+<a href="https://github.com/spring-cloud/spring-cloud-stream/blob/master/spring-cloud-stream/src/test/java/org/springframework/cloud/stream/function/MultipleInputOutputFunctionTests.java#L342">here</a>),</p>
+</div>
+<div class="listingblock">
+<div class="content">
+<pre class="highlightjs highlight"><code class="language-java hljs" data-lang="java">@Bean
+public Function&lt;Flux&lt;Integer&gt;, Tuple2&lt;Flux&lt;String&gt;, Flux&lt;String&gt;&gt;&gt; organise() {
+	return flux -&gt; ...;
+}</code></pre>
+</div>
+</div>
+<div class="paragraph">
+<p>Given that Project Reactor is a core dependency of SCF, we are using its Tuple library.
+Tuples give us a unique advantage by communicating to us both <em>cardinality</em> and <em>type</em> information.
+Both are extremely important in the context of SCSt. Cardinality lets us know
+how many input and output bindings need to be created and bound to the corresponding
+inputs and outputs of a function. Awareness of the type information ensures proper type
+conversion.</p>
+</div>
+<div class="paragraph">
+<p>Also, this is where the ‘index’ part of the naming convention for binding
+names comes into play, since, in this function, the two output binding
+names are <code>organise-out-0</code> and <code>organise-out-1</code>.</p>
+</div>
+<div class="admonitionblock important">
+<table>
+<tr>
+<td class="icon">
+<i class="fa icon-important" title="Important"></i>
+</td>
+<td class="content">
+IMPORTANT: At the moment, function arity is <strong>only</strong> supported for reactive functions
+(<code>Function&lt;TupleN&lt;Flux&lt;?&gt;&#8230;&#8203;&gt;, TupleN&lt;Flux&lt;?&gt;&#8230;&#8203;&gt;&gt;</code>) centered on Complex event processing
+where evaluation and computation on confluence of events typically requires view into a
+stream of events rather than single event.
+</td>
+</tr>
+</table>
+</div>
+</div>
+<div class="sect2">
 <h3 id="_kotlin_lambda_support"><a class="link" href="#_kotlin_lambda_support">Kotlin Lambda support</a></h3>
 <div class="paragraph">
 <p>We also provide support for Kotlin lambdas (since v2.0).
@@ -647,6 +610,19 @@ same rules for signature transformation outlined in "Java 8 function support" se
 autoconfiguration and supporting classes.</p>
 </div>
 </div>
+<div class="sect2">
+<h3 id="_function_component_scan"><a class="link" href="#_function_component_scan">Function Component Scan</a></h3>
+<div class="paragraph">
+<p>Spring Cloud Function will scan for implementations of <code>Function</code>,
+<code>Consumer</code> and <code>Supplier</code> in a package called <code>functions</code> if it
+exists. Using this feature you can write functions that have no
+dependencies on Spring - not even the <code>@Component</code> annotation is
+needed. If you want to use a different package, you can set
+<code>spring.cloud.function.scan.packages</code>. You can also use
+<code>spring.cloud.function.scan.enabled=false</code> to switch off the scan
+completely.</p>
+</div>
+</div>
 </div>
 </div>
 <div class="sect1">
@@ -802,7 +778,7 @@ public class DeployFunctionDemo {
 	public static void main(String[] args) {
 		ApplicationContext context = SpringApplication.run(DeployFunctionDemo.class,
 				"--spring.cloud.function.location=..../target/uppercase-0.0.1-SNAPSHOT.jar",
-				"--spring.cloud.function.function-name=uppercase");
+				"--spring.cloud.function.definition=uppercase");
 
 		FunctionCatalog catalog = context.getBean(FunctionCatalog.class);
 		Function&lt;String, String&gt; function = catalog.lookup("uppercase");