'if' point-free

Question

ile işlev yapmak Haskell'de bir görevim var (hayır, benim ödevim değil, sınava giriyorum).

iştir: Verilen listelerde elemanın oluşumlarını sayar

Yaz noktadan serbest fonksiyonu numocc. Örneğin: numocc 1 [[1, 2], [2, 3, 2, 1, 1], [3]] = [1, 2, 0]

Bu benim kodudur:

addif :: Eq a => a -> Int -> a -> Int 
addif x acc y = if x == y then acc+1 else acc 

count :: Eq a => a -> [a] -> Int 
count = flip foldl 0 . addif 

numocc :: Eq a => a -> [[a]] -> [Int] 
numocc = map . count 

numocc ve count 'nokta-ücretsiz', ancak değil işlevi addif kullanıyor.

addif noktasını serbest olarak nasıl çalıştırabilirim konusunda hiçbir fikrim yok. if ifadesi point-free yapmanın bir yolu var mı? Belki de if'u kullanan bir numara var mı?

Answer 1

ben kolayca dönüştürebilirsiniz gerçeğini kullanmak istiyorsunuz bir BoolfromEnum kullanılarak Int bir etmek:

addif x acc y = acc + fromEnum (x == y) 

Şimdi bunu işaret ücretsiz hale getirme zamanki hileler uygulayarak başlayabilirsiniz

-- Go prefix and use $ 
addif x acc y = (+) acc $ fromEnum $ (==) x y 
-- Swap $ for . when dropping the last argument 
addif x acc = (+) acc . fromEnum . (==) x 

Ve bunun gibi. Özellikle de sizin için yapabilecekleri araçlar olduğunda, bu noktaya dikkat etmeden tüm eğlenceyi almayacağım.

Alternatif olarak, neredeyse bedava işaret edilmektedir

count x = sum . map (fromEnum . (==) x) 

gibi bir fonksiyon yazabiliriz ve hızla oldukça kötü olsun her ne kadar daha yakın almak hileler vardır:

count = fmap fmap fmap sum map . fmap fmap fmap fromEnum (==) 

Burada Her fmap'u (.) ile değiştirebilmemize rağmen fmap yerine fmap'u kullanmanın daha güzel görüneceğini düşünün ve tam olarak aynı kod olacaktır.

> :t fmap fmap fmap sum map 
Num a => (a -> b) -> [a] -> b 

Yani bir işlev alır: Esasen, (fmap fmap fmap) yerine Eğer aşağı Broken

count = (sum .: map) . (fromEnum .: (==)) 

olarak bu yazabiliriz .: adını verirseniz, birlikte tek bir argüman ve iki argüman fonksiyonunu oluşturan b'dan1 nolu bir a nolu listeye ve a numaralı bir değere döner, çok kötü değil.

> :t fmap fmap fmap fromEnum (==) 
Eq a => a -> a -> Int 

Ve bu tür nota önemli bir şeydir, Eq a => a -> (a -> Int) olarak yazılabilir. Bu fonksiyonun dönüş türünüile fmap fmap fmap sum map girdisi ile eşleştirerek, Eq a => a -> [a] -> Int türünde bir işlev elde etmek için bunları oluşturabiliriz. Biz addIf farklı bir sürümünü tanımlayabilirsiniz

chk :: Bool -> (a,a) -> a 
chk = ([snd,fst]!!) . fromEnum 

chk Kullanılması: Bool için Enum örneğini kullanarak

Answer 2

Tek bir numara, birçok if functions, örn. Data.Bool.bool 1 0 (Data.Bool.Extras da bulunmaktadır).

Daha fazla bilgi, Foreign.Marshal.Utils.fromBool numaralı telefonu kullanmaktır. Veya aynı şey, daha az arcane: fromEnum (teşekkürler @bheklilr).

Ama bence en basit numara, sadece kendinizin sayılmasından kaçınmak ve sadece filter numaralı numaradan sonra standart length işlevini uygulamaktır.

Answer 3

neden olmasın

numocc x 
    = map (length . filter (== x)) 
    = map ((length .) (filter (== x))) 
    = map (((length .) . filter) (== x)) 
    = map (((length .) . filter) ((==) x)) 
    = map (((length .) . filter . (==)) x) 
    = (map . ((length .) . filter . (==))) x 
    = (map . (length .) . filter . (==)) x 

ve sonra önemsiz eta-kasılma

.

Answer 4

, o daha genel durumlarda kullanılıp kullanılamayacağını bir pointfree değiştirme oluşturmak mümkündür

addIf' :: Eq a => a -> a -> Int -> Int 
addIf' = curry (flip chk ((+1),id) . uncurry (==)) 

Şimdi biz sadece addIf' içinde chk değiştirebilirsiniz:

Answer 5

0.’un bool’u (4.7.0.0 (2014–04–08) yıllarından beri aradığınızı düşünüyorum.

incif :: (Eq a, Enum counter) => a -> a -> counter -> counter 
incif = ((bool id succ) .) . (==) 

ek .

bool ifadeyi geçirmeden önce, iki parametre alması == verir. Parametrelerin sıralaması farklı olduğundan

, böyle incif kullanmak gerekir:

(flip . incif) 

(incif içine okuyucuya bir alıştırma olarak bırakılmıştır olduğunu entegre [Çeviri:. Bu önemsiz değil, ve henüz nasıl bilmiyorum;])