Listenin son elemanı bulmak üç işlevi var:

nthElement :: [a] -> Int -> Maybe a 
nthElement [] a = Nothing
nthElement (x:xs) a | a <= 0 = Nothing
                    | a == 1 = Just x
                    | a > 1 = nthElement xs (a-1)

nthElementIf :: [a] -> Int -> Maybe a
nthElementIf [] a = Nothing
nthElementIf (x:xs) a = if a <= 1
                        then if a <= 0 
                             then Nothing
                             else Just x -- a == 1
                        else nthElementIf xs (a-1)                           

nthElementCases :: [a] -> Int -> Maybe a
nthElementCases [] a = Nothing
nthElementCases (x:xs) a = case a <= 0 of
                             True -> Nothing
                             False -> case a == 1 of
                                        True -> Just x
                                        False -> nthElementCases xs (a-1)

Benim görüşüme göre, ilk işlevi, en özlü, çünkü en iyi uygulamasıdır. Ama onları tercih yapacak diğer iki uygulamalarıyla ilgili bir şey var mı? Ve uzantısı, nasıl-sonra-eğer başka bir koruma ile arasında seçim misiniz ifadeler ve durumlar?

Teknik açıdan, tüm üç sürümleri eşdeğerdir.

Bu söyleniyor, benim başparmak kuralı için stilleri eğer okuyabiliyor sanki İngilizce (okuma | "" | otherwise "başka" ve = "" veya ""), sen muhtemelen bir şey değil.

if..then..else seni bekliyorbir ikili durumya da yapmanız gereken tek bir karar. İç içe if..then..else-ifadeler Haskell çok nadirdir, ve Muhafızlar hemen hemen her zaman yerine kullanılır.

let absOfN =
  if n < 0 -- Single binary expression
  then -n
  else  n

if..then..else Her ifade daha fazla vaka daha kolay yapabilirsiniz bu yana bir işlevi üst düzeyde olduğunu ve bu genellikle tercih edilmeli, eğer bir gardiyan tarafından değiştirilebilir:

abs n
  | n < 0     = -n
  | otherwise =  n

case..of seni bekliyorbirden fazla kod yollarve kodu her yolu tarafından yönlendirilir yapısıbir değeri, yani desen eşleştirme.) Çok nadiren True False maç.

case mapping of
  Constant v -> const v
  Function f -> map f

Korumalar case..of ifadeler, eğer bir değerine bağlı olarak, karmaşık kararlar için anlamını tamamlıyorilkkarar sizin giriş yapısına bağlı olarak, vesonrayapı değerleri karar verirler.

handle  ExitSuccess = return ()
handle (ExitFailure code)
  | code < 0  = putStrLn . ("internal error "   ) . show . abs $ code
  | otherwise = putStrLn . ("user error "   )     . show       $ code

BTW.Gibi bir stil ipucu, her zaman bir yeni satır sonra = ya önce bir | mal sonra =/| çok uzun bir satır veya daha fazla satır kullanan başka bir nedenden dolayı:

-- NO!
nthElement (x:xs) a | a <= 0 = Nothing
                    | a == 1 = Just x
                    | a > 1 = nthElement xs (a-1)

-- Much more compact! Look at those spaces we didn't waste!
nthElement (x:xs) a
  | a <= 0    = Nothing
  | a == 1    = Just x
  | otherwise = nthElement xs (a-1)