Haskell 计算满足查询的列表元素

Question

我目前正在处理 CSV 文件，将它们解析为 [[String]] 该数组中的第一个 [String] 是一个头文件，例如：

["Code","Address","Town"]

其余的是信息数组

["ABA","12,east road", "London"]

我想创建一个查询系统，其中输入和结果将如下所示

>count "Town"="*London*" @1="A*"
14 rows

列名可以作为字符串放入或者作为带有列索引的@ 我有一个大小写开关来识别第一个单词输入，因为我要扩展我的 CSV 阅读器以实现不同的功能。 当它看到字数时，它将转到一个返回行数的函数。我不确定如何开始解析查询。 起初，我想我可以将字数统计后的结果字符串拆分为每个查询的字符串列表，执行一个查询并使用满足此查询的列表再次检查下一个查询，留下一个所有查询都在其中的列表满意，然后计算条目数量并将其返回。还会有一个大小写开关来识别第一个输入是字符串还是@符号。 * 用于表示单词后面的零个或任何字符。 我不确定如何开始实施这个，或者如果我错过了我的解决方案可能遇到的问题。我将非常乐意为我的起步提供任何帮助。我对 Haskell 的了解不是很深入（因为我刚刚开始），所以我也希望保持简单。谢谢

Answer 1

这是一种可能的方法。

首先，让我们稍微远离字符串列表表示形式，让我们将记录表示为键/值对，这样数据库只是记录列表：

type Field  = (String, String) -- key, value                                    
type Record = [Field]
type Db     = [Record]

然后读取表示形式中的 CSV 数据变成：

type Csv = [[String]]

fromCsv :: Csv -> Db
fromCsv []         = []
fromCsv (ks : vss) = map (zip ks) vss

现在，让我们谈谈查询。在您的设置中，查询本质上是一个过滤器列表，其中每个过滤器标识一个字段并匹配一组值：

type Query  = [Filter]
type Filter = (Selector, ValueFilter)

按名称或基于一的（！）索引选择字段：

data Selector = FieldName String | FieldIndex Int

通过应用序列来匹配值简单解析器的组成，其中解析器要么识别单个字符，要么识别零个或多个任意字符的序列：

type ValueFilter = [Parser]
data Parser      = Char Char | Wildcard

可以使用成功列表方法来实现解析，其中每个成功表示剩余输入，即输入不是由解析器消耗。剩余输入的空列表表示失败。 （因此，请注意以下情况下生成的结果中 [] 和 [[]] 之间的差异。）

parse :: Parser -> String -> [String]
parse (Char c) (c' : cs') | c == c' = [cs']
parse Wildcard []                   = [[]]
parse Wildcard cs@(_ : cs')         = cs : parse Wildcard cs'
parse _ _                           = []

过滤值然后发展为回溯：

filterValue :: ValueFilter -> String -> Bool
filterValue ps cs = any null (go ps cs)
  where
    go [] cs       = [cs]
    go (p : ps) cs = concatMap (go ps) (parse p cs)

值选择很简单：

select :: Selector -> Record -> Maybe String
select (FieldName s) r                           = lookup s r
select (FieldIndex n) r | n > 0 && n <= length r = Just (snd (r !! (n - 1)))
                        | otherwise              = Nothing

现在应用记录过滤器相当于在记录上构建谓词：

apply :: Filter -> Record -> Bool
apply (s, vf) r = case select s r of
  Nothing -> False
  Just v  -> filterValue vf v

最后，为了执行完整的查询，我们

exec :: Query -> Db -> [Record]
exec = (flip . foldl . flip) (filter . apply)

（我将查询本身的解析作为练习：

readQuery :: String -> Maybe Query
readQuery = ...

但我建议使用解析器组合器库，例如 parsec 或 uulib。）

现在，让我们测试一下。首先，我们引入一个 CSV 格式的小型数据库：

csv :: Csv
csv =
  [ ["Name" , "City"      ]
     -------  ------------                                                      
  , ["Will" , "London"    ]
  , ["John" , "London"    ]
  , ["Chris", "Manchester"]
  , ["Colin", "Liverpool" ]
  , ["Nick" , "London"    ]
  ]

然后，我们构造一个简单的查询：

-- "Name"="*i*" @2="London"                                                     
query :: Query
query =
  [ (FieldName "Name", [Wildcard, Char 'i', Wildcard])
  , (FieldIndex 2,
      [Char 'L', Char 'o', Char 'n', Char 'd', Char 'o', Char 'n'])
  ]

事实上，对数据库运行查询会产生：

> exec query (fromCsv csv)
[[("Name","Will"),("City","London")],[("Name","Nick"),("City","London")]]

或者，如果您只是在计算查询结果之后：

> length $ exec query (fromCsv csv)
2

当然，这这只是一种方法，当然人们可以想到许多替代方法。正如我们上面所做的那样，将问题分解为小函数的一个好处是，您可以轻松地单独测试和试验解决方案的小块。

Answer 2

我对 Haskell 也不是那么精通......但我会这样处理它：你想要的本质上是：

f $ filter g list

其中“f”可以是类似“count”的东西（实际上是长度），而“g”是过滤功能与您的查询相对应。首先，您将输入分为“头”和“尾”（这将是列表）；然后你可以使用 Parsec 来解析查询。您的秒差距解析器只会返回一个元组；第一个是函数“f”（如果遇到“count”，则可能是“length”）；第二个只会返回 true/false；你会有这些类型：

f :: [String] -> Int
g :: [String] -> Bool 

使用 parsec< 构建 'f' 和 'g' 非常容易/a>.我想如果您稍微研究一下链接页面上的示例，您就会自己弄清楚。