Haskell成语，用于设置索引结构化值的集合

Question

我收集了大约十几种我定义的类型的结构化东西（比如说Component），其中每个都可以用“名称”来标识，而且努力理清一个惯用的Haskell实例化和检索方法。这些东西在我的应用程序中经常使用，因此概念上它们是一组全局常量或常量表，理想情况下这些常量将被初始化并保存以供快速检索。

我目前的做法，我不舒服，只是使用一个函数来从它的名字“计算”每个Component。

data Component = Component { 
        someData :: !String, 
        otherData :: ![Int] 
       } deriving Show 

component :: Name -> Component 
component n = case n of 
    -- about a dozen in the application 
    "1"  -> Component "lasdkfj;alksdjfalkf" [1] 
    "Q"  -> Component "nvjufhhqwe" [5,10,11] 
    "other" -> Component "ugugugu" [] 
    "A"  -> Component "alkkjsfkjaleifuhqiweufjc" [] 
    "B"  -> Component "randomletters" [] 
    "C"  -> Component "nothingimportant" [9,10] 
    "b"  -> Component "uk" [] 
    "c"  -> Component "x" [4,2,7,9,0] 
    ""  -> Component "ABC" [] 
    -- if not listed above, the Component is computed 
    otherwise -> Component (someFunctionOf n) (someOtherFunctionOf n) 

这不适合我。首先，Component的名称实际上是Component的一部分，但不包含在该类型中。更重要的是，甚至可以计算常量值，但实际上它们只能在某个表中初始化。

考虑到这一点我也试过

type Name = String 

import Data.Maybe 
import Data.Map 

data Component = Component { 
        name :: Name, 
        someDate :: String, 
        otherData :: [Int] 
       } deriving Show 

components = fromList $ (\c -> (name c, c)) <$> [ 
    Component "1" "lasdkfj;alksdjfalkf" [1], 
    Component "Q" "nvjufhhqwe" [5,10,11], 
    Component "other" "ugugugu" [], 
    Component "A" "alkkjsfkjaleifuhqiweufjc" [], 
    Component "B" "randomletters" [], 
    Component "C" "nothingimportant" [9,10], 
    Component "b" "uk" [], 
    Component "c" "x" [4,2,7,9,0], 
    Component "" "ABC" [] 
    ] 

component :: Name -> Component 
component n | isNothing c = Component n (someFunctionOf n) (someOtherFunctionOf n) 
      | otherwise = fromJust c 
     where c = Data.Map.lookup n components 

这显然已经处理了“常量”值作为常量的优势，但觉得尴尬，因为它引入了一个中间值（Mapcomponents）并在那里复制名称（在Component中并作为相应的键）。

无论如何，我觉得我正在解决这一切都是错误的，并且必须有更好的方法来建立一组索引结构化值，其中包括一堆常量和计算值。

Answer 1

您的Map为基础的解决方案看起来很好。两个小的调整：首先，你应该做一个合格的进口Data.Map，以避免名称冲突：

import qualified Data.Map as M 
import Data.Map (Map) 

第二import是那里只是为了更加方便。有了它，你不需要在类型签名中写入M.Map。

其次，isNothing和isJust不是很习惯。使用maybe,fromMaybe或简单地对Maybe值进行模式匹配更为明确。作为奖励，如果你这样做，你不需要使用fromJust（尽可能避免，因为它是部分）。

component :: Name -> Component 
component n = fromMaybe 
    (Component n (someFunctionOf n) (someOtherFunctionOf n)) 
    (M.lookup n components) 

但感觉别扭，因为它引入了一个中间值（Mapcomponents）

我知道we couldn't persuade you last time around，但实在是没有错的引入中间值。这样做可以使代码更容易理解，通过更清楚地了解每个部分正在做什么以及重用。如果您不需要其他地方的components地图（可能是这种情况），并且不想为其创建顶级定义，只需将它放在where子句中即可。

和复制有

的名字这是一个烦恼，但相对较小的一个。如果您的代码用户无权访问components字典，则不能通过更改存储组件的名称来引入错误;只有你可以这样做。不过，如果你希望尽量减少在其中可以引入错误的位数（这本身就是一个合法的目标），你可以改变的components的类型......

components :: Map Name ComponentData 

...其中ComponentData是您的原创，无名称，定义为Component。该component功能，这是一个用户实际看到的，可保留其现有的类型：刚刚推出类似...

giveNameToComponent :: Name -> ComponentData -> Component 

...并改变其定义...

component :: Name -> Component 
component n = fromMaybe 
    (Component n (someFunctionOf n) (someOtherFunctionOf n)) 
    (giveNameToComponent n <$> M.lookup n components) 

......或等同地使用maybe：

component :: Name -> Component 
component n = maybe 
    (Component n (someFunctionOf n) (someOtherFunctionOf n)) 
    (giveNameToComponent n) 
    (M.lookup n components)