Haskell'de “kaldırma” nedir?

"Kaldırma" nın ne olduğunu anlamıyorum. Bir "asansör" ne olduğunu anlamadan önce monad'ları anlamalı mıyım? (Ben de monadlar hakkında tamamen cahilim :) Yoksa birisi bana basit sözlerle açıklayabilir mi?

Kaldırma, bir matematiksel kavramdan ziyade bir tasarım modelidir (buradaki birisinin artık asansörlerin bir kategori veya başka bir şey olduğunu göstererek beni çürütmesini bekliyorum).

Genellikle bir parametre ile bazı veri türleriniz vardır. Gibi bir şey

data Foo a = Foo { ...stuff here ...}

Eğer kullanımlarının çok bulmak varsayalım Foo(sayısal türlerini dikkate alırız Int, Doublevb) ile, bu numaraları unwraps ekler veya çarpar ve sonra onları yedeklemek sarar yazma koduna sahip tutun. Paketten çıkarma ve sarma kodunu bir kez yazarak buna kısa devre yapabilirsiniz. Bu işleve geleneksel olarak "asansör" denir, çünkü şöyle görünür:

liftFoo2 :: (a -> b -> c) -> Foo a -> Foo b -> Foo c

Başka bir deyişle, iki bağımsız değişkenli bir işleve (örneğin, (+) işleç ) alıp Foos için eşdeğer işleve dönüştüren bir işleviniz vardır.

Şimdi yazabilirsiniz

addFoo = liftFoo2 (+)

Düzenle: daha fazla bilgi

Elbette sahip olabilirsiniz liftFoo3,liftFoo4 vb. Ancak bu genellikle gerekli değildir.

Gözlemle başlayın

liftFoo1 :: (a -> b) -> Foo a -> Foo b

Ama bu tam olarak aynı fmap. Yani liftFoo1yazmak yerine

instance Functor Foo where
   fmap f foo = ...

Gerçekten tam bir düzenlilik istiyorsanız şunu söyleyebilirsiniz:

liftFoo1 = fmap

FooBir fonktor haline getirebiliyorsanız , belki de onu pratik bir fonktor yapabilirsiniz. Aslında, yazabiliyorsanız liftFoo2, uygulanabilir örnek şöyle görünür:

import Control.Applicative

instance Applicative Foo where
   pure x = Foo $ ...   -- Wrap 'x' inside a Foo.
   (<*>) = liftFoo2 ($)

(<*>)Foo için operatör türüne sahip

(<*>) :: Foo (a -> b) -> Foo a -> Foo b

Sarılmış işlevi sarılmış değere uygular. Eğer uygulayabiliyorsanız liftFoo2, bunu bu açıdan yazabilirsiniz. Veya doğrudan uygulayabilir ve rahatsız etmeyin liftFoo2, çünkü Control.Applicativemodül

liftA2 :: Applicative f => (a -> b -> c) -> f a -> f b -> f c

ve benzer şekilde liftAve vardır liftA3. Ama aslında onları çok sık kullanmıyorsunuz çünkü başka bir operatör var

(<$>) = fmap

Bu şunları yazmanıza izin verir:

result = myFunction <$> arg1 <*> arg2 <*> arg3 <*> arg4

Bu terim myFunction <$> arg1, Foo içine alınmış yeni bir işlev döndürür. Bu, sırayla, (<*>)vb. Kullanılarak bir sonraki bağımsız değişkene uygulanabilir . Yani şimdi her çağ için bir kaldırma fonksiyonuna sahip olmak yerine, papatya uygulama zinciriniz var.

Paul ve yairchu'nun her ikisi de iyi açıklamalardır.

Kaldırılan işlevin isteğe bağlı sayıda bağımsız değişkene sahip olabileceğini ve aynı türden olmaları gerekmediğini eklemek isterim. Örneğin, bir liftFoo1 de tanımlayabilirsiniz:

liftFoo1 :: (a -> b) -> Foo a -> Foo b

Genel olarak, 1 argüman alan işlevlerin kaldırılması tip sınıfında yakalanır Functorve kaldırma işlemi çağrılır fmap:

fmap :: Functor f => (a -> b) -> f a -> f b

Türüyle benzerliğe dikkat edin liftFoo1. Aslında, eğer varsa liftFoo1, aşağıdakilerin Foobir örneğini yapabilirsiniz Functor:

instance Functor Foo where
  fmap = liftFoo1

Dahası, keyfi sayıda argümana kaldırmanın genelleştirilmesine uygulanabilir stil denir . Sabit sayıda argümanla işlevlerin kaldırılmasını kavrayacak kadar dalış yapmayın. Ama bunu yaptığınızda, Size bir Haskell öğrenin bu konuda iyi bir bölüm var. Typeclassopedia açıklanır başka iyi belgedir funktoru ve uygulamalı (hem de diğer tip sınıfları; kaydırma Söz konusu belgenin sağ bölüme aşağı).

Bu yardımcı olur umarım!

Bir örnekle başlayalım (daha net sunum için bir miktar beyaz boşluk eklenir):

> import Control.Applicative
> replicate 3 'a'
"aaa"
> :t replicate
replicate        ::         Int -> b -> [b]
> :t liftA2
liftA2 :: (Applicative f) => (a -> b -> c) -> (f a -> f b -> f c)
> :t liftA2 replicate
liftA2 replicate :: (Applicative f) =>       f Int -> f b -> f [b]
> (liftA2 replicate) [1,2,3] ['a','b','c']
["a","b","c","aa","bb","cc","aaa","bbb","ccc"]
> ['a','b','c']
"abc"

liftA2düz türlerin bir işlevini, listeler vb. gibi sarılı aynı türdekiApplicative bir işleve dönüştürür IO.

Başka bir ortak asansör liftdan Control.Monad.Trans. Bir monadın monadik hareketini, dönüştürülmüş bir monadın hareketine dönüştürür.

Genel olarak, "lift" bir işlevi / eylemi "kaydırılmış" türe kaldırır (böylece orijinal işlev "kaydırmalar" altında çalışmaya başlar).

Bunu ve monadları vb. Anlamanın ve neden faydalı olduklarını anlamanın en iyi yolu muhtemelen kodlamak ve kullanmaktır. Daha önce kodladığınız ve bundan fayda sağlayacağından şüphelendiğiniz bir şey varsa (yani, bu kodu kısaltacaktır, vb.), Sadece deneyin ve konsepti kolayca kavrayacaksınız.

Kaldırma, bir işlevi başka (genellikle daha genel) bir ortamda karşılık gelen bir işleve dönüştürmenizi sağlayan bir kavramdır

http://haskell.org/haskellwiki/Lifting adresine bir göz atın

Göre bu parlak öğretici bir funktor bir kap (gibidir Maybe<a>, List<a>ya da Tree<a>bir başka tür bu kutu deposu elemanları a). <a>Öğe türü için Java jenerik gösterimini kullandım ave öğeleri ağaç üzerinde çilek olarak düşünüyorum Tree<a>. Bir işlevi vardır fmapbir eleman dönüştürme işlevini alır, a->bve kap functor<a>. a->bKonteynerin etkili bir şekilde dönüştürülmesi için her eleman için geçerlidir functor<b>. Sadece ilk argüman sağlandığında a->b, fmapbekler functor<a>. Yani, a->btek başına tedarik , bu eleman düzeyindeki işlevi functor<a> -> functor<b>kaplar üzerinde çalışan işleve dönüştürür . Buna kaldırma denirfonksiyon. Konteynere functor da denildiğinden , Monad yerine Functors kaldırma için bir ön koşuldur. Monadlar kaldırmaya bir çeşit "paralel" dir. Her ikisi de Functor kavramına güvenir ve yaparlar f<a> -> f<b>. Fark, kaldırma a->bişleminin dönüşüm için kullanmasıdır , oysa Monad kullanıcının tanımlamasını gerektirir a -> f<b>.