more

1 files changed, 61 insertions, 60 deletions

diff --git a/es-es/scala-es.html.markdown b/es-es/scala-es.html.markdown
index 145c1d74..74a043a0 100644
--- a/es-es/scala-es.html.markdown
+++ b/es-es/scala-es.html.markdown
@@ -442,101 +442,102 @@ object Perro {
 // A menudo tienen pocos métodos, y los métodos raramente tienen efectos secundarios.
 case class Persona(nombre: String, telefono: String)
 
-// Create a new instance. Note cases classes don't need "new"
+// Para crear instancia nuevas, observa que las case clases no necesitan "new"
 val george = Persona("George", "1234")
 val kate = Persona("Kate", "4567")
 
-// With case classes, you get a few perks for free, like getters:
-george.phoneNumber  // => "1234"
+// Con las case clases tienes unas pocas ventajas, como el acceso a los campos:
+george.telefono  // => "1234"
 
-// Per field equality (no need to override .equals)
-Person("George", "1234") == Person("Kate", "1236")  // => false
+// Para la igualdad de campos no necesitas sobreescribir el método equals
+Persona("George", "1234") == Persona("Kate", "1236")  // => false
 
-// Easy way to copy
-// otherGeorge == Person("George", "9876")
-val otherGeorge = george.copy(phoneNumber = "9876")
+// Manera fácil de copiar
+// otroGeorge == Persona("George", "9876")
+val otroGeorge = george.copy(telefono = "9876")
 
-// And many others. Case classes also get pattern matching for free, see below.
+// Y muchas otras. Las case clases también tienen comparación de patrones, que veremos más abajo.
 
 // Traits
-// Similar to Java interfaces, traits define an object type and method
-// signatures. Scala allows partial implementation of those methods.
-// Constructor parameters are not allowed. Traits can inherit from other
-// traits or classes without parameters.
+// De manera similar a las interfaces Java, los traits definen un tipo de objeto y métodos.
+// Scala permite la implementación parcial de dichos métodos.
+// No se permiten parámetros de constructor. Los traits pueden heredar de otros traits o
+// clases sin parámetros.
 
-trait Dog {
-	def breed: String
+trait Perro {
+	def raza: String
 	def color: String
-	def bark: Boolean = true
-	def bite: Boolean
+	def ladra: Boolean = true
+	def muerde: Boolean
 }
-class SaintBernard extends Dog {
-	val breed = "Saint Bernard"
-	val color = "brown"
-	def bite = false
+class SanBernardo extends Perro {
+	val raza = "San Bernardo"
+	val color = "marrón"
+	def muerde = false
 }  
 
 scala> b  
-res0: SaintBernard = SaintBernard@3e57cd70  
-scala> b.breed  
-res1: String = Saint Bernard  
-scala> b.bark  
+res0: SanBernardo = SanBernardo@3e57cd70  
+scala> b.raza  
+res1: String = San Bernardo  
+scala> b.ladra
 res2: Boolean = true  
-scala> b.bite  
+scala> b.muerde
 res3: Boolean = false  
 
-// A trait can also be used as Mixin. The class "extends" the first trait,
-// but the keyword "with" can add additional traits.
+// Un trait tambien puede ser usado mezclado con otros traits. 
+// La clase extiende el primer trait, pero la palabra "with" 
+// puede añadir traits adicionales.
 
-trait Bark {
-	def bark: String = "Woof"
+trait Ladra {
+	def ladra: String = "Guau"
 }
-trait Dog {
-	def breed: String
+trait Perro {
+	def raza: String
 	def color: String
 }
-class SaintBernard extends Dog with Bark {
-	val breed = "Saint Bernard"
-	val color = "brown"
+class SanBernardo extends Perro with Ladra {
+	val raza = "San Bernardo"
+	val color = "marrón"
 }
 
-scala> val b = new SaintBernard
-b: SaintBernard = SaintBernard@7b69c6ba
-scala> b.bark
-res0: String = Woof
+scala> val b = new SanBernardo
+b: SanBernardo = SanBernardo@7b69c6ba
+scala> b.ladra
+res0: String = Guau
 
 
 /////////////////////////////////////////////////
-// 6. Pattern Matching
+// 6. Comparación de patrones
 /////////////////////////////////////////////////
 
-// Pattern matching is a powerful and commonly used feature in Scala. Here's how
-// you pattern match a case class. NB: Unlike other languages, Scala cases do
-// not need breaks, fall-through does not happen.
+// La comparación de patrones es una poderosa función de Scala.
+// Ahora veremos como comparar patrones en una case clase. 
+// Nota: A diferencia de otros lenguajes, Scala "cases" no necesitan
+// "break", porque no ejecuta los "case" posteriores.
 
-def matchPerson(person: Person): String = person match {
-  // Then you specify the patterns:
-  case Person("George", number) => "We found George! His number is " + number
-  case Person("Kate", number)   => "We found Kate! Her number is " + number
-  case Person(name, number)     => "We matched someone : " + name + ", phone : " + number
+def comparaPersona(persona: Persona): String = persona match {
+  // Aqui especificas los patrones:
+  case Persona("George", telefono) => "Hemos encontrado a George! Su número es " + telefono
+  case Persona("Kate", telefono)   => "Hemos encontrado a Kate! Su número es " + telefono
+  case Persona(nombre, telefono)     => "Hemos encontrado alguien : " + nombre + ", teléfono : " + telefono
 }
 
-// Regular expressions are also built in.
-// Create a regex with the `r` method on a string:
+// Las expresiones regulares también están incorporadas.
+// Creas una expresión regular con el método `r` en una cadena:
 val email = "(.*)@(.*)".r
 
-// Pattern matching might look familiar to the switch statements in the C family
-// of languages, but this is much more powerful. In Scala, you can match much
-// more:
-def matchEverything(obj: Any): String = obj match {
-  // You can match values:
-  case "Hello world" => "Got the string Hello world"
+// La comparación de patrones puede parecerse al bloque switch en la familia de lenguajes de C,
+// pero aquí es mucho más poderosa. En Scala, puedes hacer más comparaciones:
+def comparaTodo(obj: Any): String = obj match {
+  // Puedes comparar valores:
+  case "Hola mundo" => "Tengo la cadena Hola mundo"
 
-  // You can match by type:
-  case x: Double => "Got a Double: " + x
+  // Puedes comparar tipos:
+  case x: Double => "Tengo un double: " + x
 
-  // You can specify conditions:
-  case x: Int if x > 10000 => "Got a pretty big number!"
+  // Puedes especificar condiciones:
+  case x: Int if x > 10000 => "Tengo un número muy grande!"
 
   // You can match case classes as before:
   case Person(name, number) => s"Got contact info for $name!"