Add document for support array result

docs/actions-docker.md

@@ -236,6 +236,18 @@ DATE=`date`
 echo "{ \"message\": \"Hello $NAME! It is $DATE.\" }"
 ```
 
+For the return result, not only support `dictionary` but also support `array`
+```
+#!/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
+```
+#!/bin/bash
+echo $1
+```
+
 - Create an action from this shell script.
 
 ```

docs/actions-dotnet.md

@@ -79,6 +79,47 @@ cd out
 zip -r -0 helloDotNet.zip *
 ```
 
+For the return result, not only support `dictionary` but also support `array`
+
+So a very simple `hello array` function would be:
+
+```csharp
+using System;
+using Newtonsoft.Json.Linq;
+namespace Apache.OpenWhisk.Tests.Dotnet
+{
+    public class HelloArray
+    {
+        public JArray Main(JObject args)
+        {
+            JArray jarray = new JArray();
+            jarray.Add("a");
+            jarray.Add("b");
+            return (jarray);
+        }
+    }
+}
+```
+
+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:
+
+```csharp
+using System;
+using Newtonsoft.Json.Linq;
+namespace Apache.OpenWhisk.Tests.Dotnet
+{
+    public class HelloPassArrayParam
+    {
+        public JArray Main(JArray args)
+        {
+            return (args);
+        }
+    }
+}
+```
+
 ### Create the .NET Core Action
 
 You need to specify the name of the function handler using `--main` argument.

docs/actions-go.md

@@ -58,6 +58,31 @@ func Main(obj map[string]interface{}) map[string]interface{} {
 }
 ```
 
+For the return result, not only support `map[string]interface{}` but also support `[]interface{}`
+
+So a very simple `hello array` function would be:
+
+```go
+package main
+// Main is the function implementing the action
+func Main(event map[string]interface{}) []interface{} {
+        result := []interface{}{"a", "b"}
+        return 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:
+
+```go
+package main
+// Main is the function implementing the action
+func Main(obj []interface{}) []interface{} {
+        return obj
+}
+```
+
 You can deploy it with just:
 
 ```

docs/actions-java.md

@@ -48,6 +48,34 @@ public class Hello {
 }
 ```
 
+Not only support return JsonObject but also support return JsonArray, the main function would be:
+
+```java
+import com.google.gson.JsonArray;
+import com.google.gson.JsonObject;
+public class HelloArray {
+    public static JsonArray main(JsonObject args) {
+        JsonArray jsonArray = new JsonArray();
+        jsonArray.add("a");
+        jsonArray.add("b");
+        return jsonArray;
+    }
+}
+```
+
+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 would be:
+
+```java
+import com.google.gson.JsonArray;
+public class Sort {
+    public static JsonArray main(JsonArray args) {
+        return args;
+    }
+}
+```
+
 Then, compile `Hello.java` into a JAR file `hello.jar` as follows:
 ```
 javac Hello.java

docs/actions-nodejs.md

@@ -31,6 +31,32 @@ and demonstrate how to bundle multiple JavaScript files and third party dependen
   }
   ```
 
+  For the return result, not only support `dictionary` but also support `array`
+
+  So a very simple `hello array` function would be:
+
+  ```javascript
+  function main(params) {
+    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.
+
+  So the function can be:
+
+  ```javascript
+  /**
+   * Sort a set of lines.
+   * @param lines An array of strings to sort.
+   */
+  function main(msg) {
+      var lines = msg || [];
+      lines.sort();
+      return lines;
+  }
+  ```
+
   The JavaScript file might contain additional functions.
   However, by convention, a function called `main` must exist to provide the entry point for the action.
 

docs/actions-php.md

@@ -47,6 +47,32 @@ function main(array $args) : array
 }
 ```
 
+For the return result, not only support `dictionary` but also support `array`
+
+So a very simple `hello array` function would be:
+
+```php
+<?php
+function main(array $args) : array
+{
+    $arr=array("a","b","c");
+    return $arr;
+}
+```
+
+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:
+
+```php
+<?php
+function main(array $args) : array
+{
+    $result = array_reverse($args);
+    return $result;
+}
+```
+
 PHP actions always consume an associative array and return an associative array.
 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-python.md

@@ -33,7 +33,23 @@ def main(args):
     print(greeting)
     return {"greeting": greeting}
 ```
+For the return result, not only support `dictionary` but also support `array`
 
+So a very simple `hello array` function would be:
+
+```python
+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.
+
+So the function can be:
+
+```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,6 +39,27 @@ def main(args)
 end
 ```
 
+For the return result, not only support `dictionary` but also support `array`
+
+So a very simple `hello array` function would be:
+
+```ruby
+def main(args)
+  nums = Array["a","b"]
+  nums
+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.
+
+So the function can be
+
+```ruby
+def main(args)
+  args
+end
+```
+
 Ruby actions always consume a Hash and return a Hash.
 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-rust.md

@@ -58,6 +58,38 @@ 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`
+
+So a simple `hello array` funtion would be:
+
+```rust
+extern crate serde_json;
+use serde_derive::{Deserialize, Serialize};
+use serde_json::{Error, Value};
+pub fn main(args: Value) -> Result<Value, Error> {
+    let output = ["a", "b"];
+    serde_json::to_value(output)
+}
+```
+
+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:
+
+```rust
+extern crate serde_json;
+use serde_derive::{Deserialize, Serialize};
+use serde_json::{Error, Value};
+pub fn main(args: Value) -> Result<Value, Error> {
+    let inputParam = args.as_array();
+    let defaultOutput = ["c", "d"];
+    match inputParam {
+        None => serde_json::to_value(defaultOutput),
+        Some(x) => serde_json::to_value(x),
+    }
+}
+```
+
 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-swift.md

@@ -35,8 +35,9 @@ An action is simply a top-level Swift function. For example, create a file calle
 `hello.swift` with the following content:
 
 ```swift
-func main(args: [String:Any]) -> [String:Any] {
-    if let name = args["name"] as? String {
+func main(args: Any) -> Any {
+    let dict = args as! [String:Any]
+    if let name = dict["name"] as? String {
         return [ "greeting" : "Hello \(name)!" ]
     } else {
         return [ "greeting" : "Hello stranger!" ]
@@ -45,6 +46,27 @@ func main(args: [String:Any]) -> [String: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`
+
+So a very simple `hello array` function woule be:
+
+```swift
+func main(args: Any) -> Any {
+    var arr = ["a", "b"]
+    return arr
+}
+```
+
+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:
+
+```swift
+ func main(args: Any) -> Any {
+     return args
+ }
+```
+
 You can create an OpenWhisk action called `helloSwift` from this function as
 follows:
 

tests/dat/actions/unicode.tests/swift-4.2.txt

@@ -15,8 +15,9 @@
  * limitations under the License.
  */
 
-func main(args: [String:Any]) -> [String:Any] {
-    if let str = args["delimiter"] as? String {
+func main(args: Any) -> Any {
+    let dict = args as! [String:Any]
+    if let str = dict["delimiter"] as? String {
         let msg = "\(str) ☃ \(str)"
         print(msg)
         return [ "winter" : msg ]

tests/dat/actions/unicode.tests/swift-5.1.txt

@@ -15,8 +15,9 @@
  * limitations under the License.
  */
 
-func main(args: [String:Any]) -> [String:Any] {
-    if let str = args["delimiter"] as? String {
+func main(args: Any) -> Any {
+    let dict = args as! [String:Any]
+    if let str = dict["delimiter"] as? String {
         let msg = "\(str) ☃ \(str)"
         print(msg)
         return [ "winter" : msg ]

tests/dat/actions/unicode.tests/swift-5.3.txt

@@ -15,8 +15,9 @@
  * limitations under the License.
  */
 
-func main(args: [String:Any]) -> [String:Any] {
-    if let str = args["delimiter"] as? String {
+func main(args: Any) -> Any {
+    let dict = args as! [String:Any]
+    if let str = dict["delimiter"] as? String {
         let msg = "\(str) ☃ \(str)"
         print(msg)
         return [ "winter" : msg ]