如何解决在Haskell中使用防护比使用模式进行递归功能更好吗？
| 我只是想知道我在Haskell中布置的递归函数。使用防护比使用模式进行递归功能通常更好吗？ 我只是不确定最佳布局是什么，但我确实知道在定义如下函数时模式会更好：units :: Int -> String
units 0 = \"zero\"
units 1 = \"one\"
units n
| n == 0 = \"zero\"
| n == 1 = \"one\"
f y [] = []
f y (x:xs)
| y == 0 = ......
| otherwise = ......
f y [] = []
f 0 (x:xs) =
f y (x:xs) =
解决方法
我的一般经验法则是这样的：
当防护罩很简单地通过“ѭ4”检验时，请使用模式匹配。
使用递归时，通常会检查基本情况。因此，如果您的基本情况是简单的“ 4”格检查，请使用模式匹配。
因此，我通常会这样做：
map f [] = []
map f (x:xs) = f x : map f xs
null
== []
map f xs | null xs = []
| otherwise = f (head xs) : map f (tail xs)
f _ [] = []
f 0 _ = ...
f y (x:xs) = ...
y
units 0 = \"zero\"
units 1 = \"one\"
f xs | length xs == 0 = ...
f1 _ [] = []
f1 0 (x:xs) = [[x],xs]
f1 y (x:xs) = [x] : f1 (y - 1) xs
f2 _ [] = []
f2 y (x:xs) | y == 0 = calc 1 : f2 (- x) xs
| otherwise = calc (1 / y) : f2 (y * x) xs
where calc z = x * ...
calc
where
module Test where
units :: Int -> String
units 0 = \"zero\"
units 1 = \"one\"
unitGuarded :: Int -> String
unitGuarded n
| n == 0 = \"zero\"
| n == 1 = \"one\"
Test.units =
\\ (ds_dkU :: GHC.Types.Int) ->
case ds_dkU of _ { GHC.Types.I# ds1_dkV ->
case ds1_dkV of _ {
__DEFAULT -> Test.units3;
0 -> Test.unitGuarded2;
1 -> Test.unitGuarded1
}
}
Test.unitGuarded =
\\ (n_abw :: GHC.Types.Int) ->
case n_abw of _ { GHC.Types.I# x_ald ->
case x_ald of _ {
__DEFAULT -> Test.unitGuarded3;
0 -> Test.unitGuarded2;
1 -> Test.unitGuarded1
}
}
map f xs | null xs = []
| otherwise = f (head xs) : map f (tail xs)
head
tail
-- compiles,crashes in runtime
map f xs | not (null xs) = []
| otherwise = f (head xs) : map f (tail xs)
-- does not have any way to compile
map f (h:t) = []
map f [] = f h : map f t
-- does not give any warnings
map f xs = f (head xs) : map f (tail xs)
-- can give a warning of non-exhaustive pattern match
map f (h:t) = f h : map f t
版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 dio@foxmail.com 举报，一经查实，本站将立刻删除。