How to use Redis with MuleSoft. A quick start presentation.
Fundamentos de Scala (Scala Basics) (español) Catecbol
1. Capacitación Tecnológica
Científica para BoliviaCatecbol
La unión es la fuerza
facebook.com/catecbol @catecbol catecbol@gmail.comwww.catecbol.com
Fundamentos de Scala
University of Applied Sciences and Arts Western
Switzerland, HES-SO
Jean-Paul Calbimonte
2. Jean-Paul Calbimonte
Formación académica:
• Ingeniería de Sistemas: Universidad Católica Boliviana, Bolivia
• Master en Informática: École Polytechnique Fédérale de Lausanne EPFL, Suiza
• Doctorado en Inteligencia Artificial: Universidad Politécnica de Madrid, España
Experiencia:
• Investigador adjunto, University of Applied Sciences and Arts Western Switzerland
• Postdoctorado, École Polytechnique Fédérale de Lausanne EPFL, Suiza
• Software dev: pirAMide informatik, medspazio, Cochabamba
Área de Investigación:
• Procesamiento de streams, RDF streams, ingeniería ontológica, e-Health
http://jeanpi.org
3. Fundamentos de Scala
¿Qué es Scala?
lenguaje escalable
tipos estáticos
orientado objetos
+
funcional
sintaxis concisa
corre en JVM
compatible con Java
abstracción
concurrencia, multi-hilos
ecosistema Scala
4. Scala: ideas básicas
2. toda funcion es un valor
1. todo valor es un objeto
Scala combina ambos paradigmas
9. val num=3 //> num : Int = 3
println(num) //> 3
val texto="catecbol" //> texto : String = catecbol
val num2:Int=3 //> num2 : Int = 3
val mix="texto"+34+true //> mix : String = texto34true
var num3=3
num3 = 5
// no se puede reasignar un val
num2 = 5
// no se puede reasignar con otro tipo
num3 = "texto"
Scala: valores y variables
se infiere
el tipo
❌
declaración
explícita
❌
10. (s:String) => "cadena" + s //> res0: String => String = <function1>
val sumarPi = (num:Int) => Pi+num //> sumarPi : Int => Double = <function1>
sumarPi(23) //> res1: Double = 26.141592653589793
val calcular=(n1:Int,n2:Double) => {
val n3=n1*n2
n3*5
} //> calcular : (Int,Double) => Double = <function2>
calcular(3,4.5) //> res2: Double = 67.5
Scala: funciones
parámetro
función anónima
cuerpo de la
función
val puede ser una función
15. Scala: cadenas
val s1="cadena" //> s1 : String = cadena
s1.split('a') //> res0: Array[String] = Array(c, den)
val s2=s"$s1 es un string" //> s2 : String = cadena es un string
val num=34.56 //> num : Double = 34.56
val s3=f"$s1 y un valor de $num%2.1f" //> s3 : String = cadena y un valor de 34.6
val s4="""cadena de
varias
líneas""" //> s4 : String = cadena de
//| varias
//| líneas
16. Scala: cadenas
"ab,cd,ef;gh;ij".split(",|;")
//> res1: Array[String] = Array(ab, cd, ef, gh, ij)
val r="[a-z]+".r
//> r : scala.util.matching.Regex = [a-z]+
r.findFirstIn("2653abc7878") match {
case Some(patron)=>patron } //> res2: String =
abc
17. Scala: clases
class Banda(nombre:String,genero:String)
val kjarkas=new Banda("Kjarkas","folclore")
class Musico(val nombre:String,banda:Banda) {
def cantar(cancion:String)={
println(s"♫♫ $cancion ♫♫")
}
}
val elmer=new Musico("Elmer Hermosa",kjarkas)
elmer.cantar("bolivia") //> ♫♫ bolivia ♫♫
println(elmer.nombre) //> Elmer Hermosa
println(elmer.banda)
19. Scala: traits
trait Artista{
val nombre:String
val edad:Int
}
class Cantante(val nombre:String, val edad:Int, val discos:Int)
extends Artista
class Actor(val nombre:String,val edad:Int,val peilculas:Int)
extends Artista
val luzmila=new Cantante("Luzmila Carpio",50,30
val jenny=new Actor("Jenny Serrano",40,2)
val artistas=Seq(luzmila,jenny)
artistas.foreach(artista=>println(artista.nombre))
//> Luzmila Carpio
//| Jenny Serrano
20. Scala: clases
class Cancion(val titulo:String)
trait Cantante{
def cantar(cancion:Cancion)
}
trait Compositor{
def componer(titulo:String):Cancion
}
class Cantautor extends Cantante with Compositor{
def componer(titulo:String)={
new Cancion(titulo)
}
def cantar(cancion:Cancion)=
println(s"♫♫ ${cancion.titulo} ♫♫")
}
val matilde=new Cantautor
val regreso=matilde.componer("Regreso")
matilde.cantar(regreso) //> ♫♫ Regreso ♫♫
22. Scala: clases case
case class PlatoTipico(nombre:String,departamento:String)
val majao=PlatoTipico("majadito","Santa Cruz")
val fricase=PlatoTipico("fricase","La Paz")
println(majao.departamento)
//> Santa Cruz
val majadito=PlatoTipico("majadito","Santa Cruz")
majao == majadito
//> res0: Boolean = true
val sonso=majao.copy(nombre="sonso")
println(sonso)
//> PlatoTipico(sonso,Santa Cruz)
23. Scala: match case
def evaluar(nota:String)={
nota match {
case "A" => 70
case "B" => 50
case "F" => 30
case _ => 0
}
} //> evaluar: (nota: String)Int
evaluar("B") //> res0: Int = 50
evaluar("h") //> res1: Int = 0
def verificar(a:Any)=a match{
case "A" => "una letra A"
case 4 => "un int 45"
case 4.5 => "un double 4.5"
} //> verificar: (a: Any)String
verificar("A") //> res2: String = una letra A
// match error
verificar("a")
24. Scala: match case
def verificar2(a:Any)=a match {
case s:String => "string"
case d:Double => "double"
case i:Int => "int"
case _ => "otro"
}
//> verificar2: (a: Any)String
Seq("ab",5,3.4,"2",List).map(verificar2)
//> res3: Seq[String] = List(string, int, double, string, otro)
25. Scala: match case
trait Region{
val nombre:String
}
case class Departamento(nombre:String) extends Region
case class Provincia(nombre:String,dpto:Departamento) extends Region
case class Municipio(nombre:String,prov:Provincia) extends Region
val cocha=Departamento("Cochabamba")
val cercado=Provincia("Cercado",cocha)
val chuqui=Departamento("Chuquisaca")
val oropeza=Provincia("Oropeza",chuqui)
val sucre=Municipio("Sucre",oropeza)
val list:Seq[Region]=Seq(cocha,cercado,oropeza,sucre)
26. Scala: match case
val list:Seq[Region]=Seq(cocha,cercado,oropeza,sucre)
list map {
case Departamento(nom) => s"Depto $nom"
case Provincia(nom,dpto) => s"prov $nom en ${dpto.nombre}"
case Municipio(nom,prov) => s"muni $nom en ${prov.nombre}, dpto ${prov.dpto.nombre}"
}
//> res4: Seq[String] = List(Depto Cochabamba, prov Cercado en Cochabamba, prov
//| Oropeza en Chuquisaca, muni Sucre en Oropeza, dpto Chuquisaca)
list map {
case d:Departamento => s"Depto ${d.nombre}"
case p:Provincia => s"prov ${p.nombre} en ${p.dpto.nombre}"
case m:Municipio => s"muni ${m.nombre} en ${m.prov.nombre}, dpto ${m.prov.dpto.nombre}"
}
//> res5: Seq[String] = List(Depto Cochabamba, prov Cercado en Cochabamba, prov
//| Oropeza en Chuquisaca, muni Sucre en Oropeza, dpto Chuquisaca)
27. Scala: opciones
val equipos=Map("lp"->"The Strongest",
"scz"->"Oriente",
"cocha"->"Wilster",
"oru"->"San Jose")
def obtenerEquipo(dpto:String):Option[String]={
equipos.get(dpto)
}
def hayEquipo(dpto:String)=equipos.get(dpto) match {
case Some(eq) => println(s"el equipo es $eq")
case None => println("no hay equipo")
}
hayEquipo("scz") //> el equipo es Oriente
hayEquipo("abc") //> no hay equipo
28. Scala: opciones
case class Persona(nombre:String,email:Option[String])
Persona("felix",Some("felix@home.org"))
Persona("lucas",None)
35. Scala: java interop
import org.joda.time.DateTime
import collection.JavaConversions._
"esta cadena".getClass //> res0: Class[?0] = class java.lang.String
val fecha=DateTime.now //> fecha:org.joda.time.DateTime=2017-05-26T21:44:14.778+02:00
fecha.toTimeOfDay() //> res1: org.joda.time.TimeOfDay = T21:44:14.778
val javaLista=new java.util.ArrayList[String]
javaLista.add("a")
javaLista.add("b")
javaLista.add("c")
javaLista.foreach(println) //> a
//| b
//| c
javaLista.map(_.toUpperCase) //> res5: ArrayBuffer(A, B, C)
36. Scala: scalatest
class DemoTest extends FlatSpec with Matchers {
"Una cadena " should "cumplir" in{
val s="cadena"
s should not be (null)
s.length shouldBe (6)
s should startWith ("c")
s should contain ('d')
}
}
44. Capacitación Tecnológica
Científica para BoliviaCatecbol
La unión es la fuerza
facebook.com/catecbol @catecbol catecbol@gmail.comwww.catecbol.com
Capacitación Tecnológica
Científica para Bolivia
La unión es la fuerza
Gracias
jean-paul.calbimonte@hevs.ch
Jean-Paul Calbimonte
facebook.com/catecbol catecbol@gmail.comwww.catecbol.com