Haskell 初学者问题（定义对，类似于 Http 状态）

Question

我是 Haskell 初学者，必须定义一系列由 Int 和 String / ByteString 组成的已知状态，类似于 HTTP 状态，

我永远不需要从状态消息中获取状态代码。但是，我必须获取给定状态代码的状态消息。

我查看了 Network.HTTP.Types，它们为每个可能的状态代码定义了不同的“变量”、“status200”、“status201”等（类似于下面的“FoodTwo.hs”）。

如果我刚刚定义了一个返回状态代码的状态消息的函数（如下面的“FoodOne.hs”所示），则会产生什么（性能？）影响？

最重要的是，在像 C# 或 Java 这样的语言中，人们可能会声明一个静态字典，类似于 FoodThree.hs - 我不知何故怀疑这是 Haskell 方式？为什么？

-- FoodOne.hs
statusMessage :: Int -> String
statusMessage 30 = "BBQ ready"
statusMessage 40 = "Beverages served"
statusMessage rest = "Unknown Food Status"

-- FoodTwo.hs
data FoodStatus = FoodStatus {
    fstatusCode :: Int,
    fstatusMessage :: String
}

status30 = FoodStatus 30 "BBQ ready"
status40 = FoodStatus 40 "Beverages served"

-- FoodThree.hs
statusMessages = [(30,"BBQ ready"),(40,"Beverages served")]

Answer 1

-- FoodOne.hs
statusMessage :: Int -> String
statusMessage 30 = "BBQ ready"
statusMessage 40 = "Beverages served"
statusMessage rest = "Unknown Food Status"

大多数编译器会将其编译为线性搜索，因此它将具有线性运行时成本。

-- FoodTwo.hs
data FoodStatus = FoodStatus {
    fstatusCode :: Int,
    fstatusMessage :: String
}

status30 = FoodStatus 30 "BBQ ready"
status40 = FoodStatus 40 "Beverages served"

这种方法与其他方法没有可比性：它不提供给定（动态已知）Int 的状态查找。但是，对于静态已知的 Int，它是最快的：查找在编译时完成一次，因此无论有多少个不同的常量，都具有恒定的运行时成本。

-- FoodThree.hs
statusMessages = [(30,"BBQ ready"),(40,"Beverages served")]

在此列表中进行简单查找（例如通过内置的lookup函数）将涉及线性搜索，因此具有线性运行时成本。

-- FoodFour.hs
import Data.Map as M
statusMessages = fromList [(30, "BBQ ready"),(40,"Beverages served")]
message n = fromMaybe "Unknown Food Status" (M.lookup n statusMessages)

Data.Map 模块实现了平衡搜索树，每次查找所花费的时间是不同状态数量的对数。您还可以考虑 Data.IntMap，它也需要对数时间，但具有更好的常数。

-- FoodFive.hs
import Data.Array as A
(statusLo, statusHi) = (30, 40)
statusMessages = listArray (statusLo, statusHi)
    [ Just "BBQ ready"
    , Nothing
    , Nothing
    , {- ... -}
    , Just "Beverages served"
    ]
message' n = guard (statusLo <= n && n <= statusHi) >> statusMessages ! n
message = fromMaybe "Unknown Food Status" . message'

Data.Array 模块实现了不可变数组，并且每次查找都需要恒定的时间。但是，如果您的数组很稀疏，则这可能比其他方法具有更高的内存成本。

这些都是 Haskell 方式。选择一种能够在开发人员烦恼、速度和内存消耗之间进行适当权衡的语言，就像使用任何其他语言一样。

Answer 2

-- FoodThree.hs
statusMessages = [(30,"BBQ ready"),(40,"Beverages served")]

这可以很容易地在 Haskell 中使用：

fromCode n = fromMaybe "No such error" $ find ((==) n . fst) statusMessages

或者你可以使用 Data.Map：

import qualified Data.Map as Map
import Data.Maybe (fromMaybe)

codemap = Map.fromList statusMessages

fromCode n = fromMaybe "No such error" $ Map.lookup n codemap

Answer 3

像下面这样的东西可以吗？

data FoodStatus = BBQ_READY | BEVERAGES_SERVED | ...

instance Show FoodStatus where ...

toCode status = ...
fromCode num = ...

这与 FoodOne.hs 很相似，但更抽象，因此更易于操作。您可以按照自己的意愿自由地实现 fromCode，并根据需要优化性能。