anchor.diff:  ----
   
   The input will be received from the input binding defined in the `KafkaStreamsProcessor` interface and the output will be sent to the output binding.
  +In this case, the input is a stream of `String` objects and the output is a stream of `WordCount` objects.
   
   If the processor does not send any data on the outbound, then this becomes a plain Consumer bean as below.
  +In this example, we are simply receiving some data as a stream of `String` objects (`KStream<?, String>`) and possibly doing terminal operations with that data without sending any outputs.
   
   [source]
   ----
  
positive.code: 
  Here we have 3 inputs. The first function takes a `KStream` and its output is another `Function` that takes a `GlobalKTable` as its input and another function as its output.
  This last function takes another `GlobalKTable` as its input and a `KStream` is provided as this function's output which will be used as the processor's output.
  In this example, we have three curried functions. Behind the scenes, the binder will call the `apply` method on those functions in the order that they appear. 
  
  Here is the corresponding binding interface for this application.
  
negative.code:     }
  ----
  
  In the above function bean, there are two inputs and one output.
  The function that returns from the method takes a `KStream` as input, but if you look at the output of this function,, that is another function
  which takes a `KTable` as its input. The output of this second function is a `KStream` which becomes the output of the processor.
  Another way to look at this is like the following:
  
  Function 1: Function<KStream<String, Long> - KStream input; returns the output of "Function 2"
  Function 2: Function<KTable<String, String>, KStream<String, Long>> - KTable input; returns KStream<String, Long> which becomes the output of the processor.
  
  Both inputs are available as references in the method body and the applications can perform various operations on them.
  In this example we use function currying on two partial functions.
  One thing to keep in mind is that the input bindings must follow a natural order of sorting when you have multiple input bindings, otherwise the binder won't know which binding to bind for the various function inputs.
  