Bu üç kavram çok kafam karıştı.

Orada arasındaki farklılıkları göstermek için basit bir örnek. Kategori, Monoid ve Monad ?

Eğer bu soyut kavramların bir örnek varsa çok yararlı olacaktır.

Bu muhtemelen aradığın cevap değil ama neyse işte siz de

Monadlar & co bakmaktan çarpık bir şekilde.

Bu gibi soyut kavramlar da bir bakış açısı temel kavramlar, sıradan listesi işleme işlemleri gibi onları bağlamak için. O zaman, demek ki, olabilir

• Kategori (.) ameliyat yaygınlaştırır.
• Bir monoid ( ) ameliyat yaygınlaştırır.
• Bir functor map ameliyat genelleştirir.
• Uygulamalı bir functor zip (zipWith) işlem yaygınlaştırır.
• Bir monad concat ameliyat yaygınlaştırır.

Bir Kategori

Bir kategori bir dizi (ya da sınıf) nesneler ve her nesnelerin iki bağlayan oklar bir demet oluşur. Her nesne için, buna ek olarak, bir kimlik ok kendisi için bu nesne bağlama olmalı. Ayrıca, eğer orada bir ok (f) ucunda bir nesne ve başka bir (g) Bu başlar aynı nesne, sonra da bir kompozit ok denir g . f.

Haskell bu nesneleri olarak Haskell türleri kategorisini temsil eden bir typeclass olarak modellenmiş.

 class Category cat where
  id :: cat a a
  (.) :: cat b c -> cat a b -> cat a c

Bir kategori temel örnek olarak işlevleri vardır. Her fonksiyonu iki tür, her türlü bağlanır, kendini bir tip (değer) birbirine bağlayan işlevi id :: a -> a var. Fonksiyonların bileşimi normal işlev kompozisyon.

Kısacası, Haskell Bankası kategori şeylerdirfonksiyonlar gibi davranırlaryani (.) genelleştirilmiş bir versiyonu ile birbiri ardına koyabilirsiniz.

Bir Monoid

Bir monoid birim öğe ile bir dizi ve ilişkilendirilebilir bir işlemdir. Bu Haskell gibi modellenmiş

class Monoid a where
  mempty  :: a
  mappend :: a -> a -> a

Monoids yaygın örnekleri şunlardır:

• tamsayılar kümesi elemanı 0 ve operasyon 22**.
• pozitif tamsayılar kümesi, öğe 1 ve işlem 23**.
• tüm listeleri bir dizi, boş* *24 ve operasyon ( ) listesi.

Bu Haskell gibi modellenmiş

newtype Sum a = Sum {getSum :: a}
instance (Num a) => Monoid (Sum a) where
  mempty  = Sum 0
  mappend (Sum a) (Sum b) = Sum (a   b)  

instance Monoid [a] where
  mempty = []
  mappend = (  )

Monoids için kullanılan 'birleştirmek' ve şeyler biriktirir. Örneğin, 27**, tek topla, ya da düz bir liste halinde iç içe geçmiş bir liste toplamı listesini azaltmak için kullanılabilir. ( ) ( ) operasyon genelleme gibi bu da bir şekilde '' iki şey. birleştirme düşünün

Bir Functor

Haskell bir functor doğrudan 30* *işlem oldukça yaygınlaştırır bir şey değildir. Bir liste eşleme yerine, bazı haritalaryapısıliste gibi, ağaç, hatta bir G / Ç işlemi ikili. Funktor bu gibi modellenmiş

class Functor f where
  fmap :: (a->b) -> f a -> f b

map normal fonksiyon tanımı buna.

Uygulamalı Bir Functor

Uygulamalı funktorlar zipWith genelleştirilmiş bir operasyonla şeyler olarak görülebilir. Funktorlar zamanda genel yapıları üzerinde bir harita, ama Uygulamalı bir functor ile birlikte iki veya daha fazla yapılar zip edebilirsiniz. En basit örnek için, applicatives Maybe türü içinde iki tamsayılar zip beraber kullanabilirsiniz:

pure ( ) <*> Just 1 <*> Just 2  -- gives Just 3

Yapısı, örneğin: sonucu etkileyebilir dikkat edin

pure ( ) <*> Nothing <*> Just 2  -- gives Nothing

zipWith normal işlevi için bu kontrast

zipWith ( ) [1] [2]  

Sadece listeleri yerine, uygulamalı yapıların her türlü çalışır. Ayrıca, pure (<*>) ile akıllı hile bağımsız değişken herhangi bir sayı ile çalışmak için sıkıştırma yaygınlaştırır. Bunun nasıl çalıştığını görmek için, eldeki kısmen uygulanan işlevleri kavramı tutarken aşağıdaki türlerini inceleyin:

instance (Functor f) => Applicative f where
  pure  :: a -> f a
  (<*>) :: f (a -> b) -> f a -> f b

Ayrıca fmap (<*>) arasındaki benzerliğe dikkat edin.

Bir Monad

Monadlar sık sık farklı hesaplama ortamı, belirli olmayan ya da yan effectful hesaplamaları gibi modellemek için kullanılır. Zaten çok fazla monad öğreticiler uzak olduğu için, sadece yazmak yerine The best one başka tavsiye eder.

Sıradan liste işleme fonksiyonları ile ilgili, monadlar işlevi 44* *listeler ayrıca yapıların diğer birçok tür ile çalışmak için bir genelleme. Basit bir örnek olarak, join düzleştirmek için kullanılabilir monadic işlemi Maybe değerleri iç içe:

join (Just (Just 42)) -- gives Just 42
join (Just (Nothing)) -- gives Nothing

Nasıl bu yapılanma hesaplamaları aracı olarak Monadlar kullanımı ile ilgili? Bazı veritabanından üst üste iki sorguları yapmak oyuncak bir örneği ele alalım. İlk Sorgu ile başka bir arama yapmak istediğin bir anahtar değerini döndürür. Sorun burada ilk değer ile doğrudan sorgulayabilirsiniz. yani Maybe içeri alınmış. Belki de bir yerine, Functor, 50* *yeni bir sorgu ile dönüş değeri olabilir yerine. Bu yukarıdaki gibi Maybe iki iç içe geçmiş değerler verebilir. Başka bir sorgu Maybes üç katmanları neden olur. Bu oldukça zor bir program olabilir, ama bir monadic join bu yapı, dümdüz ve Maybes sadece tek bir düzeyi ile çalışmak için bir yol sağlar.

(Çok mantıklı geldiğini daha önce bu yazıyı düzenleme olacağım sanırım..)