Guards vs. if-then-else vs. cases ใน Haskell

ฉันมีฟังก์ชั่นสามอย่างที่ค้นหาองค์ประกอบที่ n ของรายการ:

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)

ในความคิดของฉันฟังก์ชั่นแรกคือการนำไปใช้งานที่ดีที่สุดเพราะมีความรัดกุมที่สุด แต่มีอะไรเกี่ยวกับการใช้งานอีกสองรายการที่จะทำให้ดีกว่านี้หรือไม่? คุณจะเลือกอย่างไรระหว่างการใช้ยามคำสั่ง if-then-else และกรณี?

จากมุมมองทางเทคนิคทั้งสามเวอร์ชันมีความเท่าเทียมกัน

ตามที่กล่าวไว้กฎง่ายๆสำหรับรูปแบบของฉันคือถ้าคุณอ่านได้เหมือนกับว่าเป็นภาษาอังกฤษ (อ่าน|ว่า "เมื่อ" | otherwiseเป็น "อย่างอื่น" และ=เป็น "เป็น" หรือ "เป็น") คุณอาจกำลังทำบางสิ่ง ขวา.

if..then..elseมีไว้สำหรับเมื่อคุณมีเงื่อนไขไบนารีหนึ่งข้อหรือการตัดสินใจเพียงครั้งเดียวที่คุณต้องทำ การif..then..elseแสดงออกที่ซ้อนกันเป็นเรื่องแปลกมากใน Haskell และควรใช้การ์ดแทนเกือบตลอดเวลา

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

ทุกif..then..elseนิพจน์สามารถถูกแทนที่ด้วยตัวป้องกันได้หากอยู่ในระดับบนสุดของฟังก์ชันและโดยทั่วไปควรเป็นที่ต้องการเนื่องจากคุณสามารถเพิ่มกรณีต่างๆได้ง่ายขึ้นจากนั้น:

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

case..ofมีไว้สำหรับเมื่อคุณมีเส้นทางรหัสหลายเส้นทางและทุกเส้นทางของรหัสจะถูกชี้นำโดย โครงสร้างของค่าเช่นผ่านการจับคู่รูปแบบ คุณไม่ค่อยตรงกับในและTrueFalse

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

Guards เสริมcase..ofนิพจน์ซึ่งหมายความว่าหากคุณจำเป็นต้องทำการตัดสินใจที่ซับซ้อนโดยขึ้นอยู่กับค่าก่อนอื่นให้ทำการตัดสินใจโดยขึ้นอยู่กับโครงสร้างของข้อมูลที่คุณป้อนจากนั้นทำการตัดสินใจเกี่ยวกับค่าในโครงสร้าง

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

BTW. ในฐานะเคล็ดลับสไตล์ให้สร้างบรรทัดใหม่หลัง=หรือก่อนหน้าเสมอ|หากสิ่งที่อยู่หลัง=/ |ยาวเกินไปสำหรับหนึ่งบรรทัดหรือใช้บรรทัดมากขึ้นด้วยเหตุผลอื่น:

-- 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)

ฉันรู้ว่านี่เป็นคำถามเกี่ยวกับสไตล์สำหรับฟังก์ชันเรียกซ้ำอย่างชัดเจน แต่ฉันขอแนะนำว่าสไตล์ที่ดีที่สุดคือการหาวิธีที่จะใช้ฟังก์ชันเรียกซ้ำที่มีอยู่ซ้ำแทน

nthElement xs n = guard (n > 0) >> listToMaybe (drop (n-1) xs)

นี่เป็นเพียงเรื่องของการสั่งซื้อ แต่ฉันคิดว่ามันอ่านง่ายมากและมีโครงสร้างแบบเดียวกับยาม

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

สิ่งสุดท้ายไม่ต้องการและหากไม่มีความเป็นไปได้อื่น ๆ ฟังก์ชันควรมี "กรณีสุดท้าย" ในกรณีที่คุณพลาดอะไรไป