Ceylon: Interoperabilidad con Java ... javax.swing

Continuamos los ejemplos del uso de librerías Java en código Ceylon. En el post anterior vimos como importar las librerías básicas de Java, ahora importaremos el paquete javax.swing.

Tendremos tres archivos:

1. module.ceylon
2. package.ceylon
3. run.ceylon

En este archivo importamos el módulo que incluye a la librería javax.swing

module.ceylon
module holaCeylon "1.0.0"{
    import java.base "7";
    import java.desktop "7";//incluye a javax.swing
}

Este archivo indicamos el paquete principal (holaCeylon) de nuestro programa.
package.ceylon
shared package holaCeylon;

El archivo que se compilará y ejecutará. Se trata de un mensaje que nos muestra la versión del lenguaje en una ventanita tipo alert.


run.ceylon
import javax.swing { JOptionPane }

shared void run(){
    JOptionPane.showMessageDialog(null,"Hola desde Ceylon ``language.version`` ");
}


Compilamos y ejecutamos:

También podemos hacer uso de showInputDialog() para introducir datos:
import javax.swing { JOptionPane }

shared void run(){
    value nombre=JOptionPane.showInputDialog("Introduce tu nombre");
    JOptionPane.showMessageDialog(null,"Hola ``nombre``");   
}

Convertir esos datos en Float o Integer. Podemos hacer un simple menú con tres opciones: calcular grados celsius, grados fahrenheit y salir.

import javax.swing { JOptionPane }

shared void run(){
    value c=Calculo();
    String? opc=JOptionPane.showInputDialog("\t1. Calcular grados Fahrenheit\n2. Calcular grados Celsius\nSalir (cualquier tecla)");

    if(exists opc){
        value opc_=opc;
        switch (opc)
        case ("1") {
            Float? numero=parseFloat(JOptionPane.showInputDialog("Introduce grado Celsius"));
            if(exists numero){
                value numero_=numero;
                JOptionPane.showMessageDialog(null,"Celsius: ``c.fahrenheit(numero)``");   
            }

        }
        case ("2") {
            Float? numero=parseFloat(JOptionPane.showInputDialog("Introduce grado Fahrenheit"));
            if(exists numero){
                value numero_=numero;
                JOptionPane.showMessageDialog(null,"Celsius: ``c.celsius(numero)``");   
            }
        }
        else {
            process.exit(0);
        }

    }
}

class Calculo(){
    shared Float celsius(Float fahr){
        return (fahr - 32) / 1.8;
    }

    shared Float fahrenheit(Float cels){
        return (1.8 * cels) + 32;
    }
}
Al compilar y ejecutar obtendremos lo siguiente:

Listo.
Links
http://ceylon-lang.org/documentation/1.1/reference/interoperability/java-from-ceylon/

Ceylon: Interoperabilidad con Java

Ceylon nos permite la interoperabilidad con Java, podemos importar sus librerías e integrarlas a nuestro código.  En este post haremos un ejemplo de como importar librerías de Java a nuestro código Ceylon.

En este caso no usaremos ningún IDE, usaremos la consola de comandos (en mi caso uso Linux). Crearemos una estructura de directorios similar a esta:
 /home/codeMonkey/Documentos/source/holaCeylon/

Tendremos estos tres archivos con la extensión *.ceylon:

1. run.ceylon
2. module.ceylon
3. package.ceylon

Dentro de cada archivo escribiremos:

run.ceylon
shared void run(){
   print("Importando librerias de Java en Ceylon");
}

module.ceylon
module holaCeylon "1.0.0"{
    import java.base "7"; // se debe tener instalada la versión 7 del JDK
}

package.ceylon
shared package holaCeylon;

Ahora volvemos al archivo run.ceylon e importamos la librería java.util.HashMap de Java.

run.ceylon
import  java.util  { HashMap }

shared void run(){
   print("Importando librerias de Java en Ceylon"); 
   value romanos = HashMap<String,Integer>();
    romanos.put("I", 1);
    romanos.put("V", 5);
    romanos.put("X", 10);
    romanos.put("L", 50);
    romanos.put("C", 100);
    romanos.put("D", 500);
    romanos.put("M", 1000);
    print(romanos.values());
}

Compilamos:
ceylon compile source/holaCeylon/run.ceylon

Cuando compilamos se crea un directorio más o menos así:

Ejecutamos: ceylon run holaCeylon/1.0.0

¡Listo!. Espero sirva de algo para quienes les interesa este lenguaje.

Aserciones

¿Qué es una Aserción?
Es una sentencia que puede ser falsa o verdadera, nos sirve para verificar o comprobar el funcionamiento de nuestro código. Básicamente es lo que supone el programador debe ocurrir en alguna parte del programa.

Un ejemplo en Java:
 int cantidad=this.getTotal();
if(cantidad < 0){
    out.out.println("la cantidad es de:"+cantidad);
}
else{
    out.println("la cantidad es de:"+cantidad);
    assert cantidad == 0 :"Parece que la cantidad no es 0";
}

En este fragmento de código vemos como usar las aserciones, en este caso usamos la palabra assert e indicamos una condición a cumplir. Las aserciones no son exclusivas de Java, también podemos encontrarlas en lenguajes como: Ceylon, Python, C++, entre otros más.

En Java 
Compilamos: javac -g Asercion.java
Ejecutamos:  java -ea Asercion

Asercion.java
import static java.lang.System.out;

public class Codemonkey{
    public static void main(String[] args) {
    ControlUsuarios cu=new ControlUsuarios();
    cu.setTotal(1);
    cu.mostrar();
    }
}

class ControlUsuarios{
    private int total=0;

    public ControlUsuarios(){

    }

    public void setTotal(int total){
        this.total=total;
    }

    public int getTotal(){
        return total;
    }

    public void mostrar(){
        int cantidad=this.getTotal();
        if(cantidad < 0){
            out.println("la cantidad es de:"+cantidad);
        }
        else{
            out.println("la cantidad es de:"+cantidad);
            assert cantidad == 0 :"Parece que la cantidad no es 0";
        }
    }

}

En Ceylon
Compilamos: ceylon compile source/Asercion.ceylon
Ejecutamos: ceylon run default

Asercion.ceylon
shared void run(){
  value cu=ControlUsuarios();
  cu.total=0;
  cu.mostrar();
}

class ControlUsuarios(){
  shared variable Integer total=0;

  shared Integer getTotal(){
    return total;
  }

  shared void mostrar(){
    Integer cantidad=this.getTotal();
    if(cantidad < 0){
      print("la cantidad es: ``cantidad``");
    }else{
      print("la cantidad es: ``cantidad``");
      assert(cantidad == 0);//Parece que la cantidad no es 0
    }
  }
}

En C++

Compilamos: g++ -o asercion  asercion.cpp
Ejecutamos: ./asercion

asercion.cpp
#include "iostream"
#include <cassert>

using namespace std;

class ControlUsuarios{
    private:
        int total;

    public:
     ControlUsuarios(){}
     virtual ~ControlUsuarios(){}
     void setTotal(int total){
         this->total=total;
     }
     int getTotal(){
         return total;
     }
     void mostrar(){
         int cantidad=this->getTotal();
         if(cantidad < 0){
            cout<<"la cantidad es de:"<<cantidad<<endl;
        }
        else{
            cout<<"la cantidad es de:"<<cantidad<<endl;
            assert(cantidad == 0); //"Parece que la cantidad no es 0";
            assert(("Parece que la cantidad no es 0",cantidad == 0));
        }
    }

};

int main(int argc, char** argv){
    ControlUsuarios cu = ControlUsuarios();
    cu.setTotal(1);
    cu.mostrar();
    return 0;
}


En Python

Ejecutamos: python Asercion.py

Asercion.py
class ControlUsuarios(object):
  total=0
  def mostrar(self):
    cantidad=self.total
    if cantidad < 0:
      print "cantidad es:",cantidad
    else:
      print "cantidad es:",cantidad
      assert cantidad == 0 #Parece que no es 0

cu=ControlUsuarios()
cu.total=1
cu.mostrar()


La verificación de programas (algoritmos) es un tema bastante extenso y complejo, este post solo trata del uso de las aserciones de manera muy superficial.

Links
http://es.axiacore.com/blog/2008/05/ejemplo-aserciones-assert-java/
http://www.lab.dit.upm.es/~lprg/material/apuntes/assert/aserciones.htm 
http://pablasso.com/200812/que-es-una-asercion/