more translated

This commit is contained in:
Pablo 2019-06-07 16:07:39 +02:00
parent a2c6510c23
commit 94c184f499

View File

@ -539,138 +539,133 @@ def comparaTodo(obj: Any): String = obj match {
// Puedes especificar condiciones: // Puedes especificar condiciones:
case x: Int if x > 10000 => "Tengo un número muy grande!" case x: Int if x > 10000 => "Tengo un número muy grande!"
// You can match case classes as before: // Puedes comparar case clases como antes:
case Person(name, number) => s"Got contact info for $name!" case Persona(nombre, telefono) => s"Tengo la información de contacto de $nombre!"
// You can match regular expressions: // Puedes comparar expresiones regulares:
case email(name, domain) => s"Got email address $name@$domain" case email(nombre, dominio) => s"Tengo la dirección de correo $nombre@$dominio"
// You can match tuples: // Puedes comparar tuplas:
case (a: Int, b: Double, c: String) => s"Got a tuple: $a, $b, $c" case (a: Int, b: Double, c: String) => s"Tengo la tupla: $a, $b, $c"
// You can match data structures: // Puedes comparar estructuras:
case List(1, b, c) => s"Got a list with three elements and starts with 1: 1, $b, $c" case List(1, b, c) => s"Tengo un alista con tres elementos que empieza con 1: 1, $b, $c"
// You can nest patterns: // Puedes anidar patrones:
case List(List((1, 2, "YAY"))) => "Got a list of list of tuple" case List(List((1, 2, "YAY"))) => "Tengo una lista de listas de tuplas"
// Match any case (default) if all previous haven't matched // Comparar cualquier case (default) si todos los anteriores no han coincido
case _ => "Got unknown object" case _ => "Tengo un objeto desconocido"
} }
// In fact, you can pattern match any object with an "unapply" method. This // De hecho puedes comparar un patrón con cualquier objeto con el método "unapply".
// feature is so powerful that Scala lets you define whole functions as // Esta función es tan poderosa que Scala te deja definir funciones enteras como patrones:
// patterns: val funcPatron: Person => String = {
val patternFunc: Person => String = { case Persona("George", telefono) => s"Teléfono de George: $telefono"
case Person("George", number) => s"George's number: $number" case Persona(nombre, telefono) => s"Teléfono de una persona aleatoria: $telefono"
case Person(name, number) => s"Random person's number: $number"
} }
///////////////////////////////////////////////// /////////////////////////////////////////////////
// 7. Functional Programming // 7. Programación funcional
///////////////////////////////////////////////// /////////////////////////////////////////////////
// Scala allows methods and functions to return, or take as parameters, other // Scala permite a los métodos y funciones devolver o
// functions or methods. // recibir como parámetros otras funciones o métodos
val add10: Int => Int = _ + 10 // A function taking an Int and returning an Int val suma10: Int => Int = _ + 10 // Una función que recibe y devuelve un Int
List(1, 2, 3) map add10 // List(11, 12, 13) - add10 is applied to each element List(1, 2, 3) map suma10 // List(11, 12, 13) - suma10 es aplicado a cada elemento
// Anonymous functions can be used instead of named functions: // Las funciones anónimas pueden ser usadas en vez de funciones con nombre:
List(1, 2, 3) map (x => x + 10) List(1, 2, 3) map (x => x + 10)
// And the underscore symbol, can be used if there is just one argument to the // Y la barra baja puede ser usada si solo hay un argumento en la función anónima.
// anonymous function. It gets bound as the variable // Se usa como la variable.
List(1, 2, 3) map (_ + 10) List(1, 2, 3) map (_ + 10)
// If the anonymous block AND the function you are applying both take one // Si el bloque anónimo Y la función que estás usando usan los dos un argumento,
// argument, you can even omit the underscore // puedes incluso omitir la barra baja.
List("Dom", "Bob", "Natalia") foreach println List("Dom", "Bob", "Natalia") foreach println
// Combinators // Combinadores
// Using `s` from above: // Usando s de arriba:
// val s = Set(1, 3, 7) // val s = Set(1, 3, 7)
s.map(sq) s.map(sq)
val sSquared = s. map(sq) val sCuadrado = s. map(sq)
sSquared.filter(_ < 10) sSquared.filter(_ < 10)
sSquared.reduce (_+_) sSquared.reduce (_+_)
// The filter function takes a predicate (a function from A -> Boolean) and // La función filter toma un predicado (una función A -> Boolean) y
// selects all elements which satisfy the predicate // selecciona todos los elementos que satisfacen el predicado.
List(1, 2, 3) filter (_ > 2) // List(3) List(1, 2, 3) filter (_ > 2) // List(3)
case class Person(name: String, age: Int) case class Persona(nombre: String, edad: Int)
List( List(
Person(name = "Dom", age = 23), Persona(nombre = "Dom", edad = 23),
Person(name = "Bob", age = 30) Persona(nombre = "Bob", edad = 30)
).filter(_.age > 25) // List(Person("Bob", 30)) ).filter(_.edad > 25) // List(Persona("Bob", 30))
// Certain collections (such as List) in Scala have a `foreach` method, // Ciertas colecciones (como List) en Scala tienen un método `foreach`,
// which takes as an argument a type returning Unit - that is, a void method // que toma como argumento un tipo que devuelva Unit (un método void)
val aListOfNumbers = List(1, 2, 3, 4, 10, 20, 100) val unaListaDeNumeros = List(1, 2, 3, 4, 10, 20, 100)
aListOfNumbers foreach (x => println(x)) unaListaDeNumeros foreach (x => println(x))
aListOfNumbers foreach println unaListaDeNumeros foreach println
// For comprehensions // Para comprensiones
for { n <- s } yield sq(n) for { n <- s } yield sq(n)
val nSquared2 = for { n <- s } yield sq(n) val nCuadrado2 = for { n <- s } yield sq(n)
for { n <- nSquared2 if n < 10 } yield n for { n <- nSquared2 if n < 10 } yield n
for { n <- s; nSquared = n * n if nSquared < 10} yield nSquared for { n <- s; nSquared = n * n if nSquared < 10} yield nSquared
/* NB Those were not for loops. The semantics of a for loop is 'repeat', whereas /* Nota: Esos no son bucles. La semántica de un bucle es repetir, mientras que un for de comprension define una relación entre dos conjuntos de datos.*/
a for-comprehension defines a relationship between two sets of data. */
///////////////////////////////////////////////// /////////////////////////////////////////////////
// 8. Implicits // 8. Implicitos
///////////////////////////////////////////////// /////////////////////////////////////////////////
/* WARNING WARNING: Implicits are a set of powerful features of Scala, and /* ATENCIÓN ATENCIÓN: Los implicitos son un conjunto de poderosas características de Scala
* therefore it is easy to abuse them. Beginners to Scala should resist the * y es fácil abusar de ellos. Si eres principiante en Scala deberías resistir la tentación
* temptation to use them until they understand not only how they work, but also * de usarlos hasta que entiendas no solo como funcionan, sino también las mejores prácticas
* best practices around them. We only include this section in the tutorial * con ellos. Nosotros solo incluiremos esta sección en el tutorial porque son tan comunes
* because they are so commonplace in Scala libraries that it is impossible to * en las librerias de Scala que es imposible hacer algo significativo sin usar una librería
* do anything meaningful without using a library that has implicits. This is * que tenga implicitos. Esto es para que entiendas como funcionan los implicitos, no para
* meant for you to understand and work with implicits, not declare your own. * que definas los tuyos propios.
*/ */
// Any value (vals, functions, objects, etc) can be declared to be implicit by // Cualquier valor (val, funciones, objetos, etc) puede ser declarado como implicito usando
// using the, you guessed it, "implicit" keyword. Note we are using the Dog // la palabra "implicit". Observa que usamos la clase Perro de la sección 5.
// class from section 5 in these examples. implicit val miEnteroImplicito = 100
implicit val myImplicitInt = 100 implicit def miFunciónImplicita(raza: String) = new Perro("Golden " + raza)
implicit def myImplicitFunction(breed: String) = new Dog("Golden " + breed)
// By itself, implicit keyword doesn't change the behavior of the value, so // Por si misma, la palabra implicit no cambia el comportamiento de un valor,
// above values can be used as usual. // así que estos valores pueden ser usados como siempre.
myImplicitInt + 2 // => 102 miEnteroImplicito + 2 // => 102
myImplicitFunction("Pitbull").breed // => "Golden Pitbull" miFunciónImplicita("Pitbull").raza // => "Golden Pitbull"
// The difference is that these values are now eligible to be used when another // La diferencia es que estos valores ahora pueden ser usados cuando otra pieza de código
// piece of code "needs" an implicit value. One such situation is implicit // necesite un valor implicito. Una situación así puede darse con argumentos implicitos de función:
// function arguments: def enviaSaludos(aQuien: String)(implicit cuantos: Int) =
def sendGreetings(toWhom: String)(implicit howMany: Int) = s"Hola $aQuien, $cuantos saludos a ti y a los tuyos!"
s"Hello $toWhom, $howMany blessings to you and yours!"
// If we supply a value for "howMany", the function behaves as usual // Si proporcionamos un valor para "cuantos", la función se comporta como siempre
sendGreetings("John")(1000) // => "Hello John, 1000 blessings to you and yours!" enviaSaludos("John")(1000) // => "Hola John, 1000 saludos a ti y a los tuyos!"
// But if we omit the implicit parameter, an implicit value of the same type is // Pero si omitimos el parámetro implicito, un valor implicito del mismo tipo es usado,
// used, in this case, "myImplicitInt": // en este caso, "miEnteroImplicito":
sendGreetings("Jane") // => "Hello Jane, 100 blessings to you and yours!" enviaSaludos("Jane") // => "Hello Jane, 100 blessings to you and yours!"
// Implicit function parameters enable us to simulate type classes in other // Los parámetros de función implicit nos permiten simular clases tipo en otros lenguajes funcionales.
// functional languages. It is so often used that it gets its own shorthand. The // Es usado tan a menudo que tiene su propio atajo. Las dos siguientes lineas significan lo mismo:
// following two lines mean the same thing:
// def foo[T](implicit c: C[T]) = ... // def foo[T](implicit c: C[T]) = ...
// def foo[T : C] = ... // def foo[T : C] = ...