style="display:inline-block;width:728px;height:90px"
data-ad-client="ca-pub-5164839828746352"
data-ad-slot="7563230308">

Scala IDE


Ahora que tuve un poco de tiempo de probar varios lenguajes como: Scala, Ceylon, Clojure, etc. encontré este sitio Scala IDE http://scala-ide.org/

Se trata de un IDE (plugin) para crear programas en Scala desde Eclipse.

En Eclipse basta poner este link:
http://download.scala-ide.org/releases-29/stable/site
Y la verdad no pude evitarlo, quise probarlo con un código que hice en Groovy haber como quedaba:

Horoscopo.scala

object horoscopo{

   def main(args: Array[String]){
      var resto=0;
      val anyos=List(1981,1982,1983,1984,1985,1986,1987,1988,1989,1990,1991,1992,1993,1994,1995,1996,1997,1998,1999,2000,2001,2002,2003,2004,2005,2006,2007,2008,2009,2010,2011,2012);
      var horos=""
      println("[Horoscopo chino en Scala]");
        for(val i <- anyos){
           resto=i%12
           
           if(resto==0){
              horos="mono"
            }
           if(resto==1){
              horos="gallo"
           }
           
           if(resto==2){
              horos="perro"
            }
           if(resto==3){
              horos="cerdo"
           }

           if(resto==4){
              horos="rata"
            }
           if(resto==5){
              horos="buey"
           }
           
           if(resto==6){
              horos="tigre"
            }
           if(resto==7){
              horos="conejo"
           }
           if(resto==8){
              horos="dragon"
           }

           if(resto==9){
              horos="serpiente"
            }
           if(resto==10){
              horos="caballo"
           }
           
           if(resto==11){
              horos="cabra"
            }
           
           println("si naciste en: "+i+" te corresponde el anyo del: "+horos)
           
         }
         
    }
}

Comentarios

Opciones de visualización de comentarios

Seleccione la forma que prefiera para mostrar los comentarios y haga clic en «Guardar las opciones» para activar los cambios.
Imagen de Sr. Negativo

Scala y otros lenguajes

Instala este plugin es bastante sencillo.

Crear un proyecto Scala

Crear aplicación

Ya habia hecho una breve comparativa con otros lenguajes:

http://www.javamexico.org/foros/groovy/groovycomparativa_con_otros_lenguajes.

Semejanzas con Groovy Python

Horoscopo.groovy

def anyos=[1981,1982,1983,1984,1985,1986,1987,1988,1989,1990,1991,1992,1993,1994,1995,1996,1997,1998,1999,2000,2001,2002,2003,2004,2005,2006,2007,2008,2009,2010,2011,2012]
def resto=0
def horos=""
println "\t[Horoscopo chino en Groovy]\n"
for (int e:anyos){
  resto=e%12
  switch(resto){
  case 0:
                horos="mono"
                break
                case 1:
                horos="gallo"
                break
                case 2:
                horos="perro"
                break
                case 3:
                horos="cerdo"
                break
                case 4:
                horos="rata"
                break
                case 5:
                horos="buey"
                break
                case 6:
                horos="tigre"
                break
                case 7:
                horos="conejo"
                break
                case 8:
                horos="dragon"
                break
                case 9:
                horos="serpiente"
                break
                case 10:
                horos="caballo"
                break
                case 11:
                horos="cabra"
                break
  }
 
 
 
  println "Si nacistes en $e  te corresponde el signo: $horos "
}

Horoscopo.py

resto,i=0,0
horos=""
print "\t[Horoscopo chino en Python]\n"
for i in range(len(anyos)):
    resto=anyos[i]%12

    if resto==0:
        horos="mono"

    if resto==1:
        horos="gallo"

    if resto==2:
        horos="perro"

    if resto==3:
        horos="cerdo"

    if resto==4:
        horos="rata"

    if resto==5:
        horos="buey"

    if resto==6:
        horos="tigre"

    if resto==7:
        horos="conejo"

    if resto==8:
        horos="dragon"

    if resto==9:
        horos="serpiente"

    if resto==10:
        horos="caballo"

    if resto==11:
        horos="cabra"

    print "Si naciste en",anyos[i]," te corresponde el signo: ",horos

Imagen de Sr. Negativo

Otros ejemplos

Mostrar los primeros 20 números pares al cuadrado
Python
Cuadrados.py

numeros=[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20]
print [x*2 for x in numeros if x%2==0]

Scala
Cuadrados.scala

object Cuadrados extends App {
  val numeros=List(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20);
  for(val elemento <- numeros){
    var opera=elemento*2;
     if(opera%2==0){
       println(opera);
     }
  }
 
}

Groovy

Cuadrados.groovy

def numeros=[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20]
 numeros.each(){
   def opera=it*2
   if(opera%2==0){
   println(opera)
   }
 }
Imagen de greeneyed

¿Por que usar listas para los numeros?

¿Cual es la razón para usar listas para almacenar una serie de numeros? ¿Es algún requerimiento del código para la comparación o algo? No pasa nada, pero me parece que os trozos de código son mucho más complicados de lo que podría/debería y me pregunto si es por algún tema en particular.

Aparte de que los últimos fragmentos no parecen correctos (Scala/Groovy). Primero hacen el cuadrado y luego mira si es par... cuando el enunciado dice "los pares al cuadrado", no "aquellos cuyo cuadrado es par".

Imagen de ezamudio

Scala

Cuadrados.scala: 1 to 20 filter { _%2==0 } map { n=> n*n }

Imagen de bferro

La sintaxis dulce de Scala

Para aquellos que no les queda claro la sintaxis dulce del código que escribe Enrique:

1 to 20 filter { _%2==0 } map { n=> n*n }

equivale a lo siguiente,escrito muy verboso:

val rango = new Range.Inclusive(1,20,1)       // Creamos un rango de 1 a 20 en pasos de 1.
val filtro = new Function1[Int, Boolean] {        //La función que recibirá filter
                   def apply(arg:Int) = {
                      arg % 2 == 0
                   }
                 }
val mapeo = new Function1[Int,Int] {              // La función que recibirá map
                      def apply(arg:Int) = {
                        arg * arg
                      }
                    }
val rangoFiltrado = rango.filter(filtro)                             // aplicamos el método filter
val rangoFiltradoMapeado = rangoFiltrado.map(mapeo)  // aplicamos el método map

// La verbosidad de Ryz :P (

// La verbosidad de Ryz :P ( digo pus yastamos mezclando lenguajes no? )
1.to(20).filter((i:Int){
   i.%(2).==(0)
}).map((n:Int){
   n.*(n)
})
Imagen de echan

alternativa

Si en algun momento ocupamos filter y map en la misma expresion tambien contamos con nuestro amigo collect.

1 to 20 collect{ case x if x % 2 == 0 => x * x  }

cualquiera de los dos se ve muy cool.

Imagen de Sr. Negativo

Sinceridad

Sello de sinceridad:
Mis más sinceras disculpas si no queda satisfecho al 100% con el código (chiste)

Perdón pero apenas estoy estudiando el lenguaje :P !!!

MicroAporte

Bueno, pues yo tengo otra idea de como hacer el horoscopo chino en scala, algo menos verboso (a mi parecer)

def horoscopoChino(anyos : String*) : Unit = {
        val animals = List("mono", "gallo", "perro", "cerdo", "rata", "buey", "tigre", "conejo", "dragon", "serpiente", "caballo", "cobra")
        val correspondientes = anyos.map(a => animals(a.toInt % 12))
        for(val x <- correspondientes){ println(x)}
      }

Espero y si jale bien, sin errores ni nada...creo que es algo más declarativo que lo que vi.

Imagen de ezamudio

ultimo

en vez de for(val x <- correspondientes){ println(x)} puedes hacer simplemente correspondientes foreach println

Re: último

Cool...quedando en:

def horoscopoChino(anyos : String*) : Unit = {
--val animals = List("mono", "gallo", "perro", "cerdo", "rata", "buey", "tigre", "conejo", "dragon", "serpiente", "caballo", "cobra")
--val correspondientes = anyos.map(a => animals(a.toInt % 12))
--correspondientes foreach println
}

O para los raperos:

def horoscopoChino(anyos : String*) : Unit = {
        val animals = List("mono", "gallo", "perro", "cerdo", "rata", "buey", "tigre", "conejo", "dragon", "serpiente", "caballo", "cobra")
        anyos.map(a => animals(a.toInt % 12)) foreach println
}

Re: Otros ejemplos

Mostrar los primeros 20 números pares al cuadrado...Lo que entiendo en este es mostrar los 20 números pares al cuadrado. Creo que la solución en Python es:

def first_twenty_even():
--index=0
--i=1
--while index<20:
----if i%2==0:
------print i**2
------index+=1
----i += 1

mmm a ver

ya me emocione, segun san yo en python seria asi
los primeros 20 numeros pares al cuadrado

if __name__ == '__main__':
        for i in range(2,41):
                if i%2==0: print i*i
        salida = raw_input("Presiona una tecla para continuar...");

y en groovy

41.times{ if(!(it%2)){ println it*it }}

Me gusta más la

Me gusta más la "comprehensión de listas" que puso Mr(-)

 
[x*2 for x in range(2,41) if x%2==0]

Hasta se lee diferente:

Multiplica x por dos para x en el rango de 2 a 41 si x modulo 2 es cero

Re: Me gusta más la

Una corrección sería:
[x**2 for x in range(2,41) if x%2==0]
Porqué piden cuadrarlos no multiplicarlos por dos :).

Yo lo dejaría en una función más "flexible":

def get_nst_squares(must=20):
--for x in [x**2 for x in range(2, int((must * 2) + 1)) if x%2==0] :
----print x
#hago el parsing a int porqué al ser tipado dinámico,
#no se sabe si un graciosito te pone 1.5 y el intérprete
#te arroja una advertencia de deprecating.
Imagen de Sr. Negativo

Groovy javesco .. carta del tarot

static int obtenerSuma(String cad){
int sumaTotal=0
  for(int i=0;i<cad.length();i++){
    char caracter=cad.charAt(i)
    String cadena=String.valueOf(caracter)
    sumaTotal+=Integer.parseInt(cadena)
  }
  return sumaTotal
}

static String tuCarta(int s){

  if(s==1){
    return "El Mago"
   
  }

  if(s==2){
    return "La Papisa"
   
  }

  if(s==3){
    return "La Emperatriz"
   
  }

  if(s==4){
    return "El Emperador"
   
  }

  if(s==5){
    return "El Papa"
   
  }

  if(s==6){
    return "El Enamorado"
   
  }

  if(s==7){
    return "El Carro"
   
  }

  if(s==8){
    return "La Justicia"
   
  }

  if(s==9){
    return "El Ermitaño"
   
  }

  if(s==10){
    return "La Rueda"
   
  }

  if(s==11){
    return "La Fuerza"
   
  }

  if(s==12){
    return "El Colgado"
   
  }

  if(s==13){
    return "La Muerte"
   
  }

  if(s==14){
    return "La Templanza"
   
  }

  if(s==15){
    return "El diablo"
   
  }

  if(s==16){
    return "La Torre"
   
  }

 if(s==17){
    return "La Estrella"
   
  }

  if(s==18){
    return "La Luna"
   
  }

  if(s==19){
    return "El Sol"
   
  }

  if(s==20){
    return "El Juicio"
   
  }

  if(s==21){
    return "El Mundo"
   
  }

  if(s==22){
    return "El Loco"
   
  }

 

}

static void defineCarta(String dia,String mes, String nuevo){
   int sumaparc=0
   int aux=0
   String cade=null
if(mes.equals("enero")){
   aux=1
 
}
if(mes.equals("febrero")){
  aux=2
 
}
if(mes.equals("marzo")){
  aux=3
 
}
if(mes.equals("abril")){
  aux=4
 
}

if(mes.equals("mayo")){
  aux=5
 
}
if(mes.equals("junio")){
  aux=6
 
}
if(mes.equals("julio")){
  aux=7
 
}
if(mes.equals("agosto")){
  aux=8
 
}
if(mes.equals("septiembre")){
  aux=9
 
}

if(mes.equals("octubre")){
 aux=10
 
}
if(mes.equals("noviembre")){
 aux=11
   
}
if(mes.equals("diciembre")){
  aux=12
 
 }
 
  sumaparc=Integer.parseInt(dia)+aux+Integer.parseInt(nuevo)
   cade=String.valueOf(sumaparc)
   println("La carta que te corresponde es: "+tuCarta(obtenerSuma(cade)))
}

String dia="13"
String mes="febrero"
String nuevo="2012"

defineCarta(dia,mes,nuevo)

Aprender un nuevo o nuevos lenguajes si que es dificil ...

El problema del código no es que no funciones si no que sigo "pensando" de manera javesca :( !!

Imagen de Sr. Negativo

... y peor con Scala :(

La verdad dejar de pensar de manera javesca es dificil, no es lo mismo definir una función/método/variables en Scala que en Java/Groovy, vaya que es confuso para mi ... aunque con los post de @bferro y @ezamudio más o menos entiendo lo básico

Imagen de ezamudio

Regla primordial

Cuando veas que tienes más de 3 o 4 if's comparando contra el mismo valor y son comparaciones secuenciales, es hora de refactoring. No puede ser que tengas 22 comparaciones para ver si el numero va de 1 a 22 y devolver una cadena. Mete las cadenas en una lista, valida que te pasen un número del 1 al largo de la cadena, y devuelve la cadena en la posición n-1 (para que siga funcionando el método con valores de 1 a N).

Lo mismo va para los meses.

Imagen de Sr. Negativo

Re: Regla primordial

Ando super perdido ...

def meses=["enero","febrero","marzo","abril","mayo","junio","julio","agosto","septiembre","octubre","noviembre","diciembre"]
def arcanos=["El Mago","La Papisa","La Emperatriz","El Emperador","El Papa","El Enamorado","El Carro","La Justicia","El Ermitaño","La Fuerza","El Colgado","La Muerte","La Templanza","El Diablo","La Torre","La Estrella","La Luna","El Sol","El Juicio","El Mundo","El Loco"]
def dia="18"
def mes="diciembre"
def nuevo="2012"

println("[Ver meses]")
meses.each(){
    println(it)
 
}

println("[Ver arcanos]")

arcanos.each(){
  println(it)
}

La idea original era usar el each, ... pero bueno tendre que seguir estudiandolo ... gracias por la observación

Re: Groovy javesco .. carta del tarot

Esta es la principal razón de porqué no me agrada Groovy, y esto es que no te obliga a cambiar
ni tu manera de codificar ni el paradigma de programación. No me tomen a mal, a lo que me
refiero es que si en Groovy yo tecleo:

public static void met(int k){
  if(k>0)
    System.out.println("K vale " + String.valueOf(k));
  else
    System.out.println("K es menor que 0");
}

Simplemente funciona, y a la hora en que yo no tenga idea como "se debe" hacer algo en
Groovy, pues puedo usar el estilo Java. Sin embargo esto dificulta la legibilidad del código
fuente, y más si desarrollas en grupo y las habilidades de cada uno son diferentes, si le llegas
a decir a alguien que no está empapado en Groovy: "No te apures, que al cabo la gran mayoría
de código Java se ejecuta en Groovy", pues tendríamos verdaderos casos que ni quiero imaginar.

Esa es la principal razón de porqué Groovy está "en mi lista de promesas a olvidar" xD.

Imagen de Sr. Negativo

Tarot groovy ... mejorado

Después del "regaño" de @ezamudio (jaja no es cierto) ya pude mejorar el código del tarot y del horoscopo chino:


Horoscopo.groovy

import java.util.Scanner

/*
  si naciste en 1985

  1985 mod 12 = 5

  te corresponde el signo de la : Rata

*/

def anyo=0
def resto=0
def horoscopoChino=[0:"Mono",1:"Gallo",2:"Perro",3:"Cerdo",4:"Rata",5:"Buey",6:"Tigre",7:"Conejo",8:"Dragon",9:"Serpiente",10:"Caballo",11:"Cabra"]

Scanner teclado= new Scanner(System.in)
println("[Horoscopo chino groovy]")
println("Año de nacimiento")
anyo=teclado.nextInt()
resto=anyo.mod(12)
println("El signo chino que te corresponde es: "+horoscopoChino[resto])

Tarot.groovy

import java.util.Scanner;

/*

si naciste el 12 de octubre y el año nuevo que inicia es 2012

  12+10+2012= 2034

ahora sumar cada una de las cifras de ese número

  2+0+3+4= 9

 te corresponde el signo de: La Justicia

*/

static int obtenerSuma(String cad){
int sumaTotal=0
  for(int i=0;i<cad.length();i++){
    char caracter=cad.charAt(i)
    String cadena=String.valueOf(caracter)
    sumaTotal+=Integer.parseInt(cadena)
  }
  return sumaTotal
}

def mapaArcanos=[1:"El Mago",2:"La Papisa",3:"La Emperatriz",4:"El Emperador",5:"El Papa",6:"El Enamorado",7:"El Carro",8:"La Justicia",9:"El Ermitaño",10:"La Rueda",11:"La Fuerza",12:"El Colgado",13:"La Muerte",14:"La Templanza",15:"El Diablo",16:"La Torre",17:"La Estrella",18:"La Luna",19:"El Sol",20:"El Juicio",21:"El Mundo",22:"El Loco"]
def mapaMeses=["enero":1,"febrero":2,"marzo":3,"abril":4,"mayo":5,"junio":6,"julio":7,"agosto":8,"septiembre":9,"octubre":10,"noviembre":11,"diciembre":12]

def dia=null
def mes=null
def nuevo=null
def sumaParcial=0
def cadena=null

Scanner teclado=new Scanner(System.in)

println("[Tarot en Groovy]")
println("Dia de nacimiento:")
dia=teclado.nextLine()
println("Mes de nacimiento:")
mes=teclado.nextLine()
println("Año nuevo que inicia:")
nuevo=teclado.nextLine()

sumaParcial=Integer.parseInt(dia)+mapaMeses[mes]+Integer.parseInt(nuevo)
cadena=String.valueOf(sumaParcial)
println("La carta del tarot que te corresponde es: "+mapaArcanos[obtenerSuma(cadena)])

Si, es difícil aprender un nuevo lenguaje. Y dejar de pensar de manera "javesca" igual. @wishmaster77 a mi parecer Groovy es el más fácil de aprender y es el que más me gusta de Scala, Ceylon, Clojure, ...

Re: Tarot mejorado

El del horóscopo chino basta con lo que lo dejes en un arreglo, no necesitas un mapa. Respecto a lo de que es más fácil y difícil, pues, Scala no es particularmente difícil, pero no tiene una curva de aprendizaje "natural" para alguien que viene de Java. Bueno, tiene esa curva a medias, porqué de Java uno llega queriendo usar objetos para todo, cosa que se puede hacer en Scala. Sin embargo para sacar el verdadero potencial de Scala es necesario aprender algunos conceptos de programación funcional, y es ahí en donde muchos batallamos.

Groovy es sencillo porqué a mi parecer combina lo que ya sabías de Java con una sintáctica azucarada (muy inspirada en Ruby a mi parecer), por lo que no es un cambio de manera de pensar sino más bien de codificar. En otras palabras en lugar de teclear en Java System.out.println("Hola"); sólo escribo println "Hola" o en lugar de hacer una iteración tipo for(String s : new String[]{"Pepito", "Juanito", "Perenganito"} ){ System.out.println("Hola " + s); } con Groovy me limito a ["Pepito", "Juanito", "Perenganito"].each(){ println it }. Digamos que Groovy es como un Java enfocado a la productividad. Mientras que otros lenguajes tienen otros fines distintos. Ceylon es un lenguaje de propósito general, del cual no sé su fin específico. Scala es un sistema pensado en aplicaciones escalables. Clojure por lo que he visto está enfocado más a fines matemáticos.

Imagen de Sr. Negativo

Scala ... es algo dificil pero me gusta

Es más fácil escibir  println("Hola mundo en Groovy y Scala") que hacer un programa más "completo" en java.

Clojure es muy complejo a mi parecer.

Ceylon entiendo algunas cosas ,pero se me complica todavía.

Por ejemplo, hacer un programa para convertir decimales a binarios en java tiene muchas líneas de código, con estos dos en particular no escribes tanto.
Binario.groovy

import java.util.Scanner

def numeroDecimal=0
def numeroBinario=""
def resto=0
Scanner teclado=new Scanner(System.in)
println("[Numero decimal a binario]")
println("Introduce numero decimal:")
numeroDecimal=teclado.nextInt()

println("Numero decimal leido: $numeroDecimal")

while(numeroDecimal>=2){
  resto=numeroDecimal.mod(2)
  numeroDecimal=(int)numeroDecimal/2
  numeroBinario+=String.valueOf(resto)
  //println("Numero binario parcial: $numeroBinario")

}
numeroBinario+=numeroDecimal
println("Numero binario obtenido:" +numeroBinario.reverse())

Binario.scala

object Binario{

   def main(args: Array[String]){
       
       if(args.length!=0){
        var numeroDecimal=Integer.parseInt(args(0))
        var numeroBinario=""
        var resto=0
        printf("Numero decimal leido:%d ",numeroDecimal)
       
        while(numeroDecimal>=2){
           resto=numeroDecimal%2
           numeroDecimal=entero(numeroDecimal/2)
           numeroBinario+=String.valueOf(resto)
        }
        numeroBinario+=numeroDecimal
        val sb= numeroBinario
        println("Numero binario obtenido: "+numeroBinario.reverse)
       

       }else{

          println("no hay nada que evaluar")
        }
       
   }

   def entero(entrada: Integer)= entrada.intValue()

}

style="display:inline-block;width:728px;height:90px"
data-ad-client="ca-pub-5164839828746352"
data-ad-slot="7563230308">