Records en Elm

Un registro puede contener muchos valores, y cada valor está asociado a un nombre.

Aquí se muestra un registro que representa al economista británico John A. Hobson:

> john =

|   { first = "John"

|   , last = "Hobson"

|   , age = 81

|   }

| 

{ age = 81, first = "John", last = "Hobson" }

> john.last

"Hobson"

Hemos definido un registro con tres campos que contienen información sobre el nombre y la edad de John.

También puedes acceder a los campos del registro mediante una función de acceso a campos como esta:

> john = { first = "John", last = "Hobson", age = 81 }

{ age = 81, first = "John", last = "Hobson" }

> .last john

"Hobson"

> List.map .last [john,john,john]

["Hobson","Hobson","Hobson"]

>  

A menudo es útil actualizar valores en un registro:

> john = { first = "John", last = "Hobson", age = 81 }

{ age = 81, first = "John", last = "Hobson" }

> { john | last = "Adams" }

{ age = 81, first = "John", last = "Adams" }

> { john | age = 22 }

{ age = 22, first = "John", last = "Hobson" }

Si quisieras decir estas expresiones en voz alta, dirías algo como: "Quiero una nueva versión de John cuyo apellido sea Adams" o "John cuya edad sea 22".

Ten en cuenta que al actualizar algunos campos de John, creamos un registro completamente nuevo. No sobrescribe el existente. Elm optimiza este proceso compartiendo la mayor cantidad de contenido posible. Si actualizas uno de los diez campos, el nuevo registro compartirá los nueve valores sin cambios.

Una función para actualizar las edades podría verse así:

> celebrateBirthday person =

|   { person | age = person.age + 1 }

| 

<function>

> john = { first = "John", last = "Hobson", age = 81 }

{ age = 81, first = "John", last = "Hobson" }

> celebrateBirthday john

{ age = 82, first = "John", last = "Hobson" }

¿Cuándo usar record en C#?

Desde C# 9, el lenguaje introdujo una nueva palabra clave: record. A simple vista parece una forma alternativa de declarar clases, pero su objetivo es mucho más específico: modelar datos inmutables que se comparan por valor.

Un record es un tipo de referencia que, a diferencia de las clases tradicionales, se compara por valor y está orientado a la inmutabilidad.

public record Person(string Name, int Age);

var p1 = new Person("Ada", 30);

var p2 = new Person("Ada", 30);

Console.WriteLine(p1 == p2); // True

Con clases normales (class), esta comparación daría false, porque se comparan las referencias.

Usá record cuando:

• Te interesa la comparación por valor: Por ejemplo, para representar coordenadas, dinero, personas, productos, etc.
• No necesitás mutabilidad. Los record son inmutables por defecto (aunque podés crear record class mutables, no es lo ideal).
• Estás trabajando con código funcional o DDD. Es perfecto para modelar objetos de valor (value objects).
• Querés usar with para copiar fácilmente con cambios:

var p3 = p1 with { Age = 31 };

 ¿Cuándo no usar record?

• Cuando necesitás una identidad mutable (por ejemplo, una entidad con un Id que cambia de estado).
• Cuando estás trabajando con frameworks como EF Core que esperan clases tradicionales para el mapeo.
• Cuando necesitás herencia compleja (los record funcionan bien, pero pueden agregar confusión si no se usan con cuidado).

Desde C# 10, también existe record struct: un tipo por valor que se comporta como record, pero como struct.

public readonly record struct Coordinates(int X, int Y);

Ideal para representar datos livianos inmutables, como vectores o puntos.

Si estás modelando datos que no cambian, donde la igualdad semántica importa más que la identidad, y querés un código limpio, expresivo y seguro, record es la herramienta perfecta.

¿Qué es Spring Data JPA?

JPA (Java Persistence API) es una especificación estándar de Java para el mapeo objeto-relacional (ORM), que permite interactuar con bases de datos relacionales utilizando objetos Java.

Con JPA se pueden:

    • Definir clases Java como entidades persistentes (@Entity).

    • Especificar relaciones entre entidades (uno a muchos, muchos a muchos, etc.).

    • Realizar operaciones como insertar, actualizar, eliminar y consultar datos sin escribir SQL explícito.

JPA no es una implementación, sino una interfaz estándar. Las implementaciones más comunes son:

    • Hibernate (la más usada)

    • EclipseLink

    • OpenJPA

Spring Data JPA es un módulo de Spring que simplifica el uso de JPA:

    • Permite definir interfaces de repositorio sin necesidad de implementar los métodos CRUD.

    • Integra la capa de persistencia con el resto del ecosistema de Spring (inyección de dependencias, control transaccional, validaciones, etc.).

    • Facilita la creación de consultas con nombres de método (findByNombre, findByEmailContaining, etc.).

    • Soporta JPQL, SQL nativo y consultas dinámicas.

Spring Data JPA es una abstracción sobre JPA que reduce drásticamente el código necesario para acceder a la base de datos.

Ventajas de usar JPA con Spring

    • Menos código repetitivo: no es necesario implementar manualmente métodos CRUD.

    • Integración total con Spring: todo se gestiona mediante inyección de dependencias y configuración automática.

    • Consultas declarativas: se pueden crear consultas complejas usando el nombre del método.

    • Abstracción del SQL: permite trabajar con objetos sin escribir sentencias SQL directamente.

    • Gestión automática del contexto de persistencia: Spring gestiona transacciones, apertura y cierre de conexiones.

    • Compatible con múltiples bases de datos: MySQL, PostgreSQL, H2, Oracle, SQL Server, etc.

En el siguiente post vamos con algo más práctico.