En el mundo del desarrollo de software, los patrones de diseño sirven como soluciones comprobadas a problemas comunes.
Uno de los conjuntos de patrones de diseño menos discutidos pero igualmente vitales es GRASP (Patrones de software de asignación de responsabilidad general). Los principios de GRASP a menudo se correlacionan con los principios SOLID y otros patrones de diseño de programación orientada a objetos.
GRASP, o Patrones de software de asignación de responsabilidad general, es una colección de pautas destinadas a asignar responsabilidades a clases y objetos en diseño orientado a objetos. ¿Cómo podemos utilizar estos patrones en nuestro desarrollo de Javascript (Node.js)? Por supuesto, Javascript admite clases, que se construyen de forma nativa sobre prototipos, donde podemos aplicar GRASP de manera similar a como lo haríamos en Java.
Sin embargo, en mi opinión, los patrones GRASP también se pueden aplicar a la programación funcional.

¿Qué es GRASP?

Los nueve patrones GRASP son:

1. Experto en información
2. Creador
3. Controlador
4. Acoplamiento bajo
5. Alta cohesión
6. Polimorfismo
7. Fabricación pura
8. Indirección
9. Variaciones protegidas

Experto en información

Asignar responsabilidades a funciones que tengan los datos o conocimientos requeridos para realizar una tarea. En programación funcional, este principio se puede aplicar asignando responsabilidades a funciones o módulos que tienen los datos o el contexto necesarios para realizar una tarea.

// User management module
const createUser = (name, email) => ({ name, email });

const getUserEmail = (user) => user.email;

const updateUserEmail = (user, newEmail) => ({
  ...user,
  email: newEmail,
});

const user = createUser('John Doe', '[email protected]');
console.log(getUserEmail(user));  // '[email protected]'

const updatedUser = updateUserEmail(user, '[email protected]');
console.log(getUserEmail(updatedUser));  // '[email protected]'

Creador

Utilice funciones de fábrica para crear estructuras de datos u objetos complejos. En programación funcional, si bien no tratamos las clases de la misma manera que en la programación orientada a objetos, podemos aplicar el principio Creador asignando la responsabilidad de crear estructuras de datos o inicializar objetos a funciones o módulos que tengan la información necesaria y contexto.

const createUser = (name, email) => ({ name, email });

Controlador

Utilice funciones de orden superior para manejar eventos del sistema y delegar tareas. En la programación funcional, los controladores suelen adoptar la forma de funciones que organizan el flujo de datos y acciones entre diferentes partes del sistema, garantizando que las responsabilidades estén claramente separadas.

// Example of express.js controller
const handleRequest = (req, res, userService) => {
  const user = userService.createUser(req.body.name, req.body.email);
  res.send(user);
};

Acoplamiento bajo

Asegúrese de que las funciones sean independientes y solo dependan de entradas explícitas. En programación funcional, el bajo acoplamiento se logra diseñando funciones y módulos que operan de forma independiente entre sí, con una dependencia mínima de los detalles internos de otras funciones o módulos

const sendEmail = (emailService, email) => emailService.send(email);

Alta cohesión

Alta cohesión se refiere al grado en que los elementos dentro de un módulo o función pertenecen entre sí. En programación funcional, lograr una alta cohesión significa diseñar funciones y módulos para que realicen una tarea única y bien definida o un conjunto de tareas estrechamente relacionadas.

const createUser = (name, email) => ({ name, email });
const addUser = (users, user) => [...users, user];

const createAndAddUser = (users, name, email)=>{
  const user = createUser(name, email);
  return addUser(users, user)
}
// usage
const users = [
  { name: 'Alice', email: '[email protected]' },
  { name: 'Bob', email: '[email protected]' },
];

const newUsers = createAndAddUser(users, 'Charlie', '[email protected]');

Polimorfismo

Utilice funciones de orden superior y funciones de primera clase para lograr polimorfismo. En programación funcional, el polimorfismo generalmente se logra mediante funciones de orden superior, funciones genéricas y sistemas de tipos como Typecript

const processPayment = (paymentMethod) => paymentMethod.process();

Fabricación pura

Crear funciones de utilidad que no se correspondan directamente con conceptos de dominio pero que proporcionen la funcionalidad necesaria, cuando no exista una función o clase de dominio adecuada.

const log = (message) => console.log(message);

Indirección

La dirección indirecta en la programación funcional se refiere al uso de funciones intermedias para gestionar las interacciones entre diferentes partes de un sistema. Un buen ejemplo en Node.js puede ser el Patrón Middleware.

const withNumberFilterMiddleware = (data) => data.filter(item => !isNaN(Number(item)));

Variaciones protegidas

Las variaciones protegidas en la programación funcional significan crear un diseño que sea resistente a los cambios encapsulando las partes que varían y asegurando que el resto del sistema esté protegido de estas variaciones. En programación funcional, este principio se puede aplicar mediante el uso de abstracción, inmutabilidad y encapsulación para crear código robusto y mantenible que sea menos susceptible a cambios.

const processCreditCardPayment = (amount) => {
  console.log(`Processing credit card payment of ${amount}`);
  // Credit card payment logic
};

const processPayPalPayment = (amount) => {
  console.log(`Processing PayPal payment of ${amount}`);
  // PayPal payment logic
};

const processPayment = (paymentMethod, amount) => {
  paymentMethod(amount);
};

// Use different payment methods without changing the processPayment function
processPayment(processCreditCardPayment, 100);
processPayment(processPayPalPayment, 200);

Resumen

Como puede ver, los principios GRASP se correlacionan con muchos patrones de diseño conocidos, así como con los principios SOLID. La Alta Cohesión es casi igual al principio de Responsabilidad Única y así sucesivamente.
Esos principios no son sólo principios de programación orientada a objetos, sino principios generales para programar código limpio y bien diseñado, ya sea funcional o de programación orientada a objetos.