Ballerina un lenguaje pensado para la nube, Parte 2

En el post anterior me quede con muchas ganas de ver código. Pero, si llegaste acá y no sabés de que estoy hablando o no sabés que es Ballerina ve esto: https://emanuelpeg.blogspot.com/2020/02/ballerina-un-lenguaje-pensado-para-la.html

Si queres probar el código que vamos dejando, pueden hacerlo acá : https://play.ballerina.io/

Veamos un poco de código en Ballerina y empecemos con un hola mundo:

import ballerina/io;

public function main() {
    io:println("Hello, World!");
}

Lindo pero, ahora vamos hacerlo en paralelo :

import ballerina/io;

public function main() {

    worker w1 {
        io:println("Hello, World! #m");
    }    worker w2 {
        io:println("Hello, World! #n");
    }    worker w3 {
        io:println("Hello, World! #k");
    }
}

veamos el mismo código en un servidor :

import ballerina/http;
import ballerina/log;

service hello on new http:Listener(9090) {
    resource function sayHello(http:Caller caller, http:Request req) {
        var result = caller->respond("Hello, World!");
        if (result is error) {
            log:printError("Error sending response", result);
        }
    }
}

y ahora de cliente : 

import ballerina/http;

import ballerina/io;

public function main() {

    http:Client clientEP = new ("http://www.mocky.io");

    var resp = clientEP->get("/v2/5ae082123200006b00510c3d/");    

    if (resp is http:Response) {

        var payload = resp.getTextPayload();

        if (payload is string) {

            io:println(payload);

        } else {

            io:println(payload.detail());

        }

    } else {

        io:println(resp.detail());

    }

}

Puff... lo que se puede hacer con un "hola mundo". Primera conclusión, claramente se ve que Ballerina esta ampliamente influenciado por Node y javascript. 

Veamos un objeto : 

import ballerina/io;

type Person object {

    public string name = "";

    public int age = 0;

    public Person? parent = ();

    private string email = "default@abc.com";

    string address = "No 20, Palm grove";

};

public function main() {

    Person p1 = new;

    io:println(p1.age);    

    

    Person p2 = new();

    io:println(p2.age);

    Person p3 = new Person();

    io:println(p3.age);

}

Se ve que las clases se declaran con type y se pueden hacer cosas más complejas : 

import ballerina/io;

type Person object {

    public int age;

    public string firstName;

    public string lastName;

    function __init(int age, string firstName, string lastName) {

        self.age = age;

        self.firstName = firstName;

        self.lastName = lastName;

    }

    function getFullName() returns string {

        return self.firstName + " " + self.lastName;

    }

};

public function main() {

    Person p1 = new(5, "John", "Doe");    

    io:println(p1.getFullName());

}

Ahora podemos ver la influencia de Go. Porque tiene la misma forma de manejar errores, los retorna y sigue la filosofía de que el error es un resultado más : 

import ballerina/io;

const ACCOUNT_NOT_FOUND = "AccountNotFound";

const INVALID_ACCOUNT_ID = "InvalidAccountID";

function getAccountBalance(int accountID) returns int|error {

    if (accountID < 0) {

        return error(INVALID_ACCOUNT_ID, accountID = accountID);

    } else if (accountID > 100) {

        return error(ACCOUNT_NOT_FOUND, accountID = accountID);

    }

    return 600;

}

public function main() {

    error simpleError = error("SimpleErrorType", message = "Simple error occurred");

    io:println("Error: ", simpleError.reason(),

                ", Message: ", simpleError.detail()?.message);

    int|error result = getAccountBalance(-1);

    if (result is int) {

        io:println("Account Balance: ", result);

    } else {

        io:println("Error: ", result.reason(),

                    ", Account ID: ", result.detail()["accountID"]);

    }

}

Y por último un ejemplo de interacción con Java : 

import ballerinax/java;

import ballerina/io;

function newArrayDeque() returns handle = @java:Constructor {

    class: "java.util.ArrayDeque"

} external;

function newArrayDequeWithInitialCapacity(int numElements) returns handle = @java:Constructor {

    class: "java.util.ArrayDeque",

    paramTypes: ["int"]

} external;

public function main() {

    var arrayDeque = newArrayDeque();

    io:println(arrayDeque);

    var arrayDequeWithCapacity = newArrayDequeWithInitialCapacity(10);

    io:println(arrayDequeWithCapacity);

}

No mucho que explicar, de esta manera podemos llamar clases java. 

Conclusión, me gusto!

Toma buenas cosas de diferentes lenguajes y lo mezcla de forma equilibrada. Lo único que le critico es el ";" que no lo veo necesario.  Por lo dicho, vamos a tener que estudiar un nuevo lenguaje :P

Dejo link: https://ballerina.io/v1-1/learn/by-example/