Ceylon

La República Democrática Socialista de Sri Lanka (cingalés:ශ්‍රී ලංකා ප්‍රජාතාන්ත්‍රික සමාජවාදී ජනරජය, Sri Lankā Prajathanthrika Samajavadi Janarajaya, tamil: இலங்கை சனநாயக சோஷலிசக் குடியரசு, Ilaṅkai caṉanāyaka cōṣalisak Kuṭiyarasu) es un país insular ubicado al sureste de India en Asia. Hasta 1972 era llamado Ceilán. Originalmente conocido como Heladiva, está habitada por más de veinte millones de personas.
La isla fue conocida en la Antigüedad como Lanka, Lankadvīpa, Simoundou, Taprobane, Serendib y Selan, llegando a ser denominada popularmente como la «Isla de los mil nombres». Durante su colonización, la isla tomó el nombre, en inglés, de Ceylon, que se siguió utilizando posteriormente. Su particular forma y su cercanía a la India hicieron que se la llame la «Lágrima de la India».

Además Ceylon es el nombre del nuevo lenguaje de Jboss para la JVM.

Ya escribí sobre este nuevo lenguaje de Jboss que corre sobre la JVM. Gavin escribe en su blog que el Lenguaje Java a quedado un poco viejo; por lo tanto el diseño un lenguaje llamado Ceylon que tiene como principal objetivo actualizar el lenguaje Java.

Los objetivos de Ceylon incluyen: Ser fácil de aprender tanto para desarrolladores Java como C#

• Eliminar la verbosidad de Java pero manteniendo la legibilidad
• Mejorar el tipado estático de Java
• Proveer una expresión declarativa para eliminar dependencias con xml
• Apoyar y fomentar un estilo de programación más funcional.
• Proveer soporte para meta-programación
• Proveer construcción modular.

Veamos el clasico “Hola Mundo”:

void hello() {   writeLine("Hola Mundo!");
}

Este método imprime “Hola Mundo!” por consola. Un método TopLevel como este es similar a una función C, esta es manejada directamente por el paquete que la contiene. Y esta no es parte de ningún tipo, por lo tanto no es necesario llamar a un objeto para llamar a un método TopLevel y a la vez no es necesario tener funciones estáticas.Para documentar el codigo provee una anotaciones que nos permiten hacer una documentación más natural por ejemplo:

doc "The classic Hello World program"
by "Gavin"
see (goodbye)
throws (IOException)
void hello() {
writeLine("Hello, World!");
}

Ceylon provee también mejora en el manejo de string, veamos un ejemplo:

doc "The Hello World program
 ... version 1.1!"
void hello() {
writeLine("Hello, this is Ceylon " process.languageVersion
          " running on Java " process.javaVersion "!");
}

Para el manejo de objetos nulos provee un operador ?, veamos un ejemplo:

doc "Print a personalized greeting"
void hello() {
String? name = process.arguments.first;
String greeting;
if (exists name) {
    greeting = "Hello, " name "!";
}
else {
    greeting = "Hello, World!";
}
writeLine(greeting);
}

Name es declarado como String? Lo que significa que acepta valores nulos. También podemos usar el operador ? Para no devolver valores nulos:

shared String greeting = "Hello, " + name?"World";

El operador ? Devolverá name si no es nulo, sino devolvera “World”

Celyon provee parámetros por defecto, secuencias y diferentes tipos de parametros:

void hello(String name="World") {
writeLine("Hello, " name "!");
}


//sequenced parameter
void print(String... strings) {
for (String string in strings) {
    writeLine(string);
}
}


//union type
void print(String|Named printable) {
String string;
switch (printable)
case (is String) {
    string = printable;
}
case (is Named) {
    string = printable.name;
}
writeLine(string);
}

Veamos la declaración de una clase:

doc "A personalized greeting"
class Hello(String? name) {

doc "The greeting"
shared String greeting;
if (exists name) {
    greeting = "Hello, " name "!";
}
else {
    greeting = "Hello, World!";
}

doc "Print the greeting"
shared void say(OutputStream stream) {
    stream.writeLine(greeting);
}

}

Como se puede ver no es necesario un método constructor dado que el código se ejecuta en el cuerpo de la clase.

Ahora veamos como se usa nuestra clase:

doc "Print a personalized greeting"
void hello() {
Hello(process.args.first).say(process.output);
}

La palabra new no se usa simplemente porque no es necesaria.
Las interfaces pueden tener definiciones de metodos pero no se pueden instanciar veamos un ejemplo:

shared interface Writer {

shared formal Formatter formatter;

shared formal void write(String string);

shared void writeLine(String string) {
    write(string);
    write(process.newLine);
}

shared void writeFormattedLine(String formatString, Object... args) {
    writeLine( formatter.format(formatString, args) );
}

}

shared class ConsoleWriter()
    satisfies Writer {

formatter = StringFormatter();

shared actual void write(String string) {
    writeLine(string);
}

}

Hasta aquí una pasada por este nuevo lenguaje para JVM. En mi opinión, cumple sus objetivos; pero deja mucho que desear si se lo compara con groovy o scala. Que piensan? Les gusta este nuevo lenguaje?

Dejo Link:

http://in.relation.to/Bloggers/Gavin

http://in.relation.to/Tutorials/IntroductionToCeylon