Apply review comments

Author: ningyougang

docs/actions-docker.md

@@ -236,13 +236,16 @@ DATE=`date`
 echo "{ \"message\": \"Hello $NAME! It is $DATE.\" }"
 ```
 
-For the return result, not only support `dictionary` but also support `array`
+An action supports not only a JSON object but also a JSON array as a return value.
 ```
 #!/bin/bash
 echo '["a", "b"]''
 ```
 
-And support array result for sequence action as well, the first action's array result can be used as next action's input parameter
+You can also create a sequence action with actions accepting an array param and returning an array result.
+
+You can easily figure out the parameters with the following example:
+
 ```
 #!/bin/bash
 echo $1

docs/actions-dotnet.md

@@ -79,7 +79,7 @@ cd out
 zip -r -0 helloDotNet.zip *
 ```
 
-For the return result, not only support `dictionary` but also support `array`
+An action supports not only a JSON object but also a JSON array as a return value.
 
 So a very simple `hello array` function would be:
 
@@ -100,10 +100,9 @@ namespace Apache.OpenWhisk.Tests.Dotnet
     }
 }
 ```
+You can also create a sequence action with actions accepting an array param and returning an array result.
 
-And support array result for sequence action as well, the first action's array result can be used as next action's input parameter.
-
-So the function can be:
+You can easily figure out the parameters with the following example:
 
 ```csharp
 using System;

docs/actions-go.md

@@ -58,7 +58,7 @@ func Main(obj map[string]interface{}) map[string]interface{} {
 }
 ```
 
-For the return result, not only support `map[string]interface{}` but also support `[]interface{}`
+An action supports not only a JSON object but also a JSON array as a return value.
 
 So a very simple `hello array` function would be:
 
@@ -71,9 +71,9 @@ func Main(event map[string]interface{}) []interface{} {
 }
 ```
 
-And support array result for sequence action as well, the first action's array result can be used as next action's input parameter.
+you can also create a sequence action with actions accepting an array param and returning an array result.
 
-So the function can be:
+You can easily figure out the parameters with the following example:
 
 ```go
 package main

docs/actions-java.md

@@ -48,7 +48,9 @@ public class Hello {
 }
 ```
 
-Not only support return JsonObject but also support return JsonArray, the main function would be:
+An action supports not only a JSON object but also a JSON array as a return value.
+
+So the main function would be:
 
 ```java
 import com.google.gson.JsonArray;
@@ -63,9 +65,9 @@ public class HelloArray {
 }
 ```
 
-And support array result for sequence action as well, the first action's array result can be used as next action's input parameter.
+You can also create a sequence action with actions accepting an array param and returning an array result.
 
-So the function would be:
+You can easily figure out the parameters with the following example:
 
 ```java
 import com.google.gson.JsonArray;

docs/actions-nodejs.md

@@ -31,7 +31,7 @@ and demonstrate how to bundle multiple JavaScript files and third party dependen
   }
   ```
 
-  For the return result, not only support `dictionary` but also support `array`
+  An action supports not only a JSON object but also a JSON array as a return value.
 
   So a very simple `hello array` function would be:
 
@@ -41,9 +41,9 @@ and demonstrate how to bundle multiple JavaScript files and third party dependen
   }
   ```
 
-  And support array result for sequence action as well, the first action's array result can be used as next action's input parameter.
+  You can also create a sequence action with actions accepting an array param and returning an array result.
 
-  So the function can be:
+  You can easily figure out the parameters with the following example:
 
   ```javascript
   /**

docs/actions-php.md

@@ -47,7 +47,7 @@ function main(array $args) : array
 }
 ```
 
-For the return result, not only support `dictionary` but also support `array`
+An action supports not only a JSON object but also a JSON arary as a return value.
 
 So a very simple `hello array` function would be:
 
@@ -60,9 +60,9 @@ function main(array $args) : array
 }
 ```
 
-And support array result for sequence action as well, the first action's array result can be used as next action's input parameter.
+You can also create a sequence action with actions accepting an array param and returning an array result.
 
-So the function can be:
+You can easily figure out the parameters with the following example:
 
 ```php
 <?php

docs/actions-python.md

@@ -33,7 +33,8 @@ def main(args):
     print(greeting)
     return {"greeting": greeting}
 ```
-For the return result, not only support `dictionary` but also support `array`
+
+An action supports not only a JSON object but also a JSON array as a return value.
 
 So a very simple `hello array` function would be:
 
@@ -42,14 +43,15 @@ def main(args):
     return ["a", "b"]
 ```
 
-And support array result for sequence action as well, the first action's array result can be used as next action's input parameter.
+You can also create a sequence action with actions accepting an array param and returning an array result.
 
-So the function can be:
+You can easily figure out the parameters with the following example:
 
 ```python
 def main(args):
     return args
 ```
+
 Python actions always consume a dictionary and produce a dictionary.
 The entry method for the action is `main` by default but may be specified explicitly when creating
 the action with the `wsk` CLI using `--main`, as with any other action type.

docs/actions-ruby.md

@@ -39,7 +39,7 @@ def main(args)
 end
 ```
 
-For the return result, not only support `dictionary` but also support `array`
+An action supports not only a JSON object but also a JSON array as a return value.
 
 So a very simple `hello array` function would be:
 
@@ -50,9 +50,9 @@ def main(args)
 end
 ```
 
-And support array result for sequence action as well, the first action's array result can be used as next action's input parameter.
+You can also create a sequence action with actions accepting an array param and returning an array result.
 
-So the function can be
+You can easily figure out the parameters with the following example:
 
 ```ruby
 def main(args)

docs/actions-rust.md

@@ -58,7 +58,7 @@ pub fn main(args: Value) -> Result<Value, Error> {
 
 Rust actions are mainly composed by a `main` function that accepts a JSON `serdes Value` as input and returns a `Result` including a JSON `serde Value`.
 
-For the return result, not only support `A JSON serde Value` but also support `Array serde Value`
+An action supports not only a JSON object but also a JSON array as a return value.
 
 So a simple `hello array` funtion would be:
 
@@ -71,10 +71,9 @@ pub fn main(args: Value) -> Result<Value, Error> {
     serde_json::to_value(output)
 }
 ```
+You can also create a sequence action with actions accepting an array param and returning an array result.
 
-And support array result for sequence action as well, the first action's array result can be used as next action's input parameter.
-
-So the function can be:
+You can easily figure out the parameters with the following example:
 
 ```rust
 extern crate serde_json;

docs/actions-swift.md

@@ -46,7 +46,7 @@ func main(args: Any) -> Any {
 ```
 In this example the Swift action consumes a dictionary and produces a dictionary.
 
-For the return result, not only support `dictionary`, but also support `array`
+An action supports not only a JSON object but also a JSON array as a return value.
 
 So a very simple `hello array` function woule be:
 
@@ -57,9 +57,9 @@ func main(args: Any) -> Any {
 }
 ```
 
-And support array result for sequence action as well, the first action's array result can be used as next action's input parameter.
+You can also create a sequence action with actions accepting an array param and returning an array result.
 
-So the function can be:
+You can easily figure out the parameters with the following example:
 
 ```swift
  func main(args: Any) -> Any {