Göz korkutucu kapak fotoğrafına rağmen, monadları mümkün olduğunca az zor matematik kullanarak açıklamaya çalışacağım. Kategori teorisinden, Kleisli'den, Curry'den bile söz edilmiyor. olmasına rağmen bir NaN.

Büyük Douglas Crockford'un sözleriyle:

İyi ve yararlı olmasının yanı sıra, aynı zamanda lanetlidir ve monadın laneti, aydınlanmayı bir kez elde ettiğinizde, bir kez anladığınızda - "ah işte budur" - bunu başka birine açıklama yeteneğinizi kaybedersiniz.

Pekala, benim bir teorim var - bunun nedeni, monadların arkasındaki matematiksel teori ve bunların nasıl uygulanması gerektiği (mükemmel örneklerle birlikte!) hakkında harika bir açıklama sağlayan bu konudaki tüm mükemmel makaleler arasında bir şeyin eksik olması:

Aslında bunlara ne için ihtiyacım var?

Öğrenmeye çalışmadan önce, bir açıklama. Bir süre önce, monadları, arkasındaki matematiği ve Kategori Teorisindeki yerlerini açıklamaya dayalı olmayan hiçbir şeye dayanarak gerçekten anlamaya çalışmamanız gerektiğini okudum. İlgilenenler için: Bu konuyu ele alan bazı mükemmel makaleler var, bunun gibi veya bunun gibi veya 1992'den itibaren programlamaya monadları getiren makale gibi . Bunları burada gerçekten tekrarlamak istemediğim için, lütfen şimdi okuyun (veya en azından tarayın) ve daha sonra buraya geri gelin (yine de bundan sonra ne olacağını anlamanın tamamen gerekli olmadığına inanıyorum).

Tamam, şimdi bunu aradan çıkardık - monad nedir? Pekala, bunu söylemenin en basit yolu, bazı değerlerin etrafındaki bir sarmalayıcıdır. İşlevsel programlama açısından, bir monad bir işlevdir , kendisine bir işlev uygulanmasına izin veren bir yapıdır . Değer ile değeri koymak istediğimiz herhangi bir işlem arasında ekstra bir soyutlama katmanıdır. Ama bu bize hiçbir şey söylemiyor.

Hayal edebileceğiniz en basit monada bir göz atalım: monadın bir uygulaması Identity:

const Identity = (value) => ({
  value: () => value,
  map: (fn) => Identity(fn(value)),
});

Mümkün olan en basit örneğe bakalım:

const addTax = (value) => value * 1.1;

const cartValue = Identity(100);

const cartValueWithTax = cartValue
  .map(addTax) // At this point this is Identity(110)
  .value(); // Equal to 110 as a number

IdentityMonad - birçok işlevsel programlama kitaplığında olduğu gibi - identityoldukça şeffaf bir mantığa sahiptir. Bu bir yer tutucu monad, identityyer tutucu işleviyle aynı. Değerimize uygulamak addTaxyukarıda verilen senaryo için iyi çalışıyor, ancak sepetimizin değeri eşit olsaydı ne olurdu bir düşünelim undefined. JavaScript'in harika çalışma şekli sayesinde , bir NaN.

addTaxGenellikle, bunu aşmanın en sezgisel yolu, işleve değer için bir kontrol eklemek olacaktır . Bu yanlış bir yaklaşımdır. İşlevin amacını gizler ve onu daha az saf hale getirir. İşlev addTaxyalnızca bir şeyi ve yalnızca bir şeyi yapmalıdır : add.Tax

Tamam, bilge adam - diyebilirsiniz - undefineddeğeri nasıl dikkate almalıyız? İşte bunun için monadlarımız var. Fonksiyonu saf tutmak istiyoruz . Ayrıca fonksiyona ilettiğimiz değere göre mantığımızın farklı davranmasını istiyoruz. Bu davranışı tanımlamak için en iyi yer functor !

Muhtemelen en popüler monada bakalım: Maybe. ofBu temel bir uygulama olabilir ( netlik için bir monad gibi karşılaşabileceğiniz olağan yöntemleri bırakıyorum ):

const Maybe = (value) => ({
  value: () => value,
  map: (fn) => value === undefined || value === null 
    ? Maybe(null) 
    : Maybe(fn(value)),
});

const primitiveCart = 100;
const undefinedCart = undefined;
const nullishCart = null;

const maybeCart = Maybe(100);
const maybeUndefinedCart = Maybe(undefined);
const maybeNullishCart = Maybe(null);


addTax(primitiveCart); // boring, 110
addTax(undefinedCart); // NaN
addTax(nullishCart); // 0 - thanks, JavaScript!

maybeCart.map(addTax).value(); // 110
maybeUndefinedCart.map(addTax).value(); // null
maybeNullishCart.map(addTax).value(); // null

Bu, elbette, monadları kullanmanın getirdiği muazzam olasılık zenginliğine sadece bir çiziktir. Diyelim ki otelimize giren her misafirimizi karşılamak istiyoruz:

const greet = (name) => `Hello, ${name}!`;

Bir temel örneğe daha göz atalım - Optionalmonad:

const Optional = (value) => ({
  value: () => value,
  orElse: (alternativeValue) => value 
    ? Optional(value) 
    : Optional(alternativeValue),
  map: (fn) => Optional(fn(value)),
});

const firstGuest = "John";
const anonymousGuest = undefined;

greet(firstGuest); // "Hello, John!"
greet(anonymousGuest); // "Hello, undefined" - this is a bit embarrasing

const OptionalWithStrangerFallback = (name) => Optional(name)
  .orElse("stranger");

const firstGuestOptional = OptionalWithStrangerFallback(firstGuest);
const anonymousGuestOptional = OptionalWithStrangerFallback(anonymousGuest);

// I really hope you know where this is going at this point

firstGuestOptional.map(greet).value(); "Hello, John!"
anonymousGuestOptional.map(greet).value(); "Hello, stranger!"

Umarım bu, monadlarla ilgili şeyleri açıklığa kavuşturur. Değilse, lütfen yorumlarda bana bildirin! Ayrıca, JavaScript, işlevsel programlama, bilgisayar görüşü, mimari, geometri, memler, teknik liderlik veya yukarıdakilerin herhangi bir karışımı hakkında daha fazla makale okumak isterseniz, beni burada veya LinkedIn'de takip ettiğinizden emin olun !