En los últimos años, los idiomas que me gusta usar se están volviendo cada vez más "funcionales". Ahora uso lenguajes que son una especie de "híbrido": C #, F #, Scala. Me gusta diseñar mi aplicación usando clases que corresponden a los objetos del dominio, y usar características funcionales donde esto hace que la codificación sea más fácil, más coincidente y más segura (especialmente cuando se opera en colecciones o cuando se pasan funciones).
Sin embargo, los dos mundos "chocan" cuando se trata de diseñar patrones. El ejemplo específico que enfrenté recientemente es el patrón Observador. Quiero que un productor notifique algún otro código (los "consumidores / observadores", digamos un almacenamiento de base de datos, un registrador, etc.) cuando se crea o cambia un elemento.
Inicialmente lo hice "funcionalmente" así:
producer.foo(item => { updateItemInDb(item); insertLog(item) })
// calls the function passed as argument as an item is processed
Pero ahora me pregunto si debería usar un enfoque más "OO":
interface IItemObserver {
onNotify(Item)
}
class DBObserver : IItemObserver ...
class LogObserver: IItemObserver ...
producer.addObserver(new DBObserver)
producer.addObserver(new LogObserver)
producer.foo() //calls observer in a loop
¿Cuáles son las ventajas y desventajas de los dos enfoques? Una vez escuché a un gurú de FP decir que los patrones de diseño están ahí solo por las limitaciones del lenguaje, y es por eso que hay tan pocos en los lenguajes funcionales. Tal vez esto podría ser un ejemplo de ello?
EDITAR: En mi caso particular, no lo necesito, pero ... ¿cómo implementaría la eliminación y la adición de "observadores" de manera funcional? (Es decir, ¿cómo implementaría todas las funcionalidades en el patrón?) ¿Simplemente pasando una nueva función, por ejemplo?