Temario curso

Tema 1: Un lenguaje escalable

• Un lenguaje que crece en ti.
• ¿Qué hace que Scala sea escalable?
• ¿Por qué Scala?
• Las raíces de Scala.

Tema 2: Primeros pasos en Scala

• Paso 1. Aprenda a usar el Scala REPL.
• Paso 2. Defina algunas variables.
• Paso 3. Defina algunas funciones.
• Paso 4. Escribe algunos scripts de Scala.
• Paso 5. Bucle con while; decidir con if.
• Paso 6. Iterar con foreach y for-do.

Tema 3: Próximos pasos en escala

• Paso 7. Parametrizar matrices con tipos.
• Paso 8. Usa listas.
• Paso 9. Usa tuplas.
• Paso 10. Usa conjuntos y mapas.
• Paso 11. Aprende a reconocer el estilo funcional.
• Paso 12. Transforma con map y for-yield.

Tema 4: Clases y objetos

• Clases, campos y métodos.
• Inferencia de punto y coma.
• Singleton objetos.
• case class.
• Una aplicación de Scala.

Tema 5: Tipos y operaciones básicas

• Algunos tipos básicos.
• Literalmente.
• Interpolación de cadenas.
• Los operadores son métodos.
• Operaciones aritméticas.
• Operaciones relacionales y lógicas.
• Operaciones bit a bit.
• Igualdad de objetos.
• Prioridad y asociatividad de operadores.
• Operaciones ricas.

Tema 6: Objetos funcionales

• Una especificación para la clase Rational.
• Construyendo un racional.
• Reimplementación del método toString.
• Comprobación de condiciones previas.
• Agregar campos.
• Autorreferencias.
• Constructores auxiliares.
• Campos y métodos privados.
• Definición de operadores.
• Identificadores en Scala.
• Sobrecarga de métodos.
• Métodos de extensión.
• Una palabra de precaución.

Tema 7: Estructuras de control integradas

• Expresiones if.
• Bucles while.
• Expresiones for.
• Control de excepciones con expresiones try.
• Expresiones de coincidencia.
• Vivir sin break y continue.
• Alcance variable.
• Refactorización de código de estilo imperativo.

Tema 8: Funciones y Closures

• Métodos.
• Funciones locales.
• Funciones de primera clase.
• Formas cortas de literales de función.
• Sintaxis del marcador de posición.
• Funciones parcialmente aplicadas.
• Closures.
• Formularios de convocatoria de funciones especiales.
• Tipos "SAM".
• Recursividad de cola.

Tema 9: Control Abstracción

• Reducción de la duplicación de código.
• Simplificación del código de cliente.
• Currying.
• Escribir nuevas estructuras de control.
• Parámetros por nombre.

Tema 10: Composición y herencia

• Una biblioteca de diseño bidimensional.
• Clases abstractas.
• Definición de métodos sin parámetros.
• Extender clases.
• Anular métodos y campos.
• Definición de campos paramétricos.
• Invocar constructores de superclase.
• Uso de modificadores override.
• Polimorfismo y unión dinámica.
• Declaración de miembros finales.
• Usando composición y herencia.
• Implementando above, beside y toString.
• Definición de un objeto factoria.
• Aumentar y ensanchar.
• Poniéndolo todo junto.

Tema 11: Traits

• Cómo funcionan los traits.
• Interfaces delgadas versus ricas.
• Traits como modificaciones apilables.
• ¿Por qué no herencias múltiples?
• Parámetros de trait.

Tema 12: Paquetes, Importaciones y Exportaciones

• Poner código en paquetes.
• Acceso conciso al código relacionado.
• Importaciones.
• Importaciones implícitas.
• Modificadores de acceso.
• Definiciones de nivel superior.
• Exportaciones.

Tema 13: Coincidencia de patrones

• Un ejemplo simple.
• Tipos de patrones.
• Protectores de patrones.
• El patrón se superpone.
• Clases selladas.
• Opciones de coincidencia de patrones.
• Patrones por todas partes.
• Un ejemplo más grande.

Tema 14: Trabajando con listas

• Enumerar literales.
• El tipo de lista.
• Construcción de listas.
• Operaciones básicas en listas.
• Patrones de lista.
• Métodos de primer orden en la clase List.
• Métodos de orden superior en la clase List.
• Métodos del objeto List.
• Procesamiento de varias listas juntas.
• Entendiendo el algoritmo de inferencia de tipos de Scala.

Tema 15: Trabajar con otras colecciones

• Secuencias.
• Sets y maps.
• Selección de colecciones mutables frente a colecciones inmutables.
• Inicialización de colecciones.
• Tuplas.

Tema 16: Objetos Mutables

• ¿Qué hace que un objeto sea mutable?
• Variables y propiedades reasignables.
• Caso práctico: Simulación de eventos discretos.
• Un lenguaje para circuitos digitales.
• La API de simulación.
• Simulación de circuitos.

Tema 17: La jerarquía de Scala

• La jerarquía de clases de Scala.
• Cómo se implementan las primitivas.
• Tipos de fondo.
• Definir sus propias clases de valor.
• Tipos de intersección.
• Tipos de unión.
• Traits transparentes.

Tema 18: Parametrización de tipos

• Colas funcionales.
• Ocultación de información.
• Anotaciones de varianza.
• Comprobación de anotaciones de varianza.
• Límites inferiores.
• Contravarianza.
• Límites superiores.

Tema 19: Enums

• Tipos de datos enumerados.
• Tipos de datos algebraicos.
• ADT generalizadas.
• ¿Qué hace que las ADT sean algebraicas?

Tema 20: Miembros abstractos

• Un recorrido rápido por los miembros abstractos.
• Escriba miembros.
• Resumen vals.
• Variables abstractas.
• Inicialización de vals abstractos.
• Tipos abstractos.
• Tipos dependientes de la ruta de acceso.
• Tipos de refinamiento.
• Estudio de caso: Monedas.

Tema 21: Givens

• Cómo funciona.
• Parametrizado tipos dados.
• Datos anónimos.
• Dados parametrizados como clases de tipo.
• Dadas las importaciones.
• Reglas para parámetros de contexto.
• Cuando se aplican múltiples dados.
• Depuración de dados.

Tema 22: Métodos de extensión

• Lo básico.
• Extensiones genéricas.
• Extensiones colectivas.
• Usando una clase de tipo.
• Métodos de extensión para dados.
• Donde Scala busca métodos de extensión.

Tema 23: Typeclasses

• ¿Por qué typeclasses?
• Límites de contexto.
• Métodos principales.
• Igualdad multiversal.
• Conversiones implícitas.
• Estudio de caso de Typeclass: Serialización JSON.

Tema 24: Colecciones en profundidad

• Colecciones mutables e inmutables.
• Consistencia de las colecciones.
• Traits iterable.
• Los rasgos de secuencia Seq, IndexedSeq y LinearSeq.
• Sets.
• Maps.
• Clases de colección inmutables concretas.
• Clases de colección mutables concretas.
• Matrices.
• Cadenas.
• Características de rendimiento.
• Igualdad.
• Vistas.
• Iteradores.
• Crear colecciones desde cero.
• Conversiones entre colecciones Java y Scala.

Tema 25: Aserciones y Pruebas

• Aserciones.
• Aserciones en Scala.
• Informes informativos de fallas.
• Pruebas según especificaciones.
• Pruebas basadas en propiedades.
• Organización y ejecución de pruebas.