Mi rendo conto che la mia comprensione precursore su Monads è gravemente carente nei dettagli considerando che la mia conoscenza proviene principalmente da Le Monade di Douglas Crockford e le Gonadi parlano e complicato con il mio handicap Sevear con Haskell (che assomiglia a un gruppo di caratteri non alfa numerici fusi tra le parole inglesi disgiunte e il mio cervello tragicamente svantaggiato).
Detto questo, vorrei chiedere informazioni sulle pratiche di programmazione relative alle Monade e su come potrebbero essere implementate in JavaScript. La presento perché riconosco che la natura stessa del linguaggio può influenzare drasticamente il modo in cui si percepisce un concetto e che a causa del mio background in JavaScript questa domanda potrebbe essere inappropriata se fosse basata su un linguaggio puramente funzionale come Haskell.
Spesso durante la progettazione di un'interfaccia o la codifica di un oggetto mi trovo ad implementare una forma di concatenamento che muta i dati incapsulati. Preferisco questo stile su forme più dichiarative come passare in un oggetto letterale multi-allineato.
function Declarative(options) {
this.options = options;
}
Declarative.prototype.compute = function() { ... }
var x = new Declarative({
foo: 'foo',
bar: 'bar'
});
x.compute();
I versi:
function Chained() { }
Chained.prototype.withFoo = function(v) {
this.foo = v;
return this;
};
Chained.prototype.withBar = function(v) {
this.bar = v;
return this;
};
Chained.prototype.compute = function() { ... }
var x = new Chained()
.withFoo('foo')
.withBar('bar')
.compute();
Entrambi questi esempi (a parte l'estetica) sollevano qualche pelo sulla mia schiena perché una piccola voce beffarda strilla "Mutabilità molto?" Comincio a pensare che questo potrebbe essere un buon momento per conciliare un modello Monad. Ciò che intendo per questo è che ogni metodo restituirà in breve un nuovo oggetto dello stesso tipo. Quindi aggiungere funzioni di composizione su di esso come la mappa, il binding, ecc. Potrebbe fuoriuscire da un mondo di potenziale come quello che ottengo con Promises e altri tipi di Monad. (Ovviamente avendo cura di seguire le tre leggi Monadiche quando implementate).
Infine, l'altra metà del mio cervello inizia a parlare con "Se tutto quello che hai è un martello, tutto sembra un chiodo". Sospiro. Questo è quando la mia produttività e creatività si infrangono qui su SE curiosi e confusi.
Mentre continuo la mia ricerca per la comprensione (forse guadagnando abbastanza coraggio per contemplare Haskell) chiedo: quando l'idea di Monade (che è la componibilità delle funzioni sugli oggetti (cioè i tipi) insieme all'immutabilità) diventa una buona idea per essere coltivato e modellato? E, quando non è altro che un martello troppo usato?
(Concetti e opportunità di apprendimento accolti, codice di esempio utile)