使用数据构造函数过滤表

Question

I'm trying to learn Haskell and I have no idea how to continue from here. I added below the part of code that matters. So I defined a Query with multiple values, and the last one I got stuck one filters the rows in the table after a specific condition. So for example it filters the rows that only have the column "Final grade" > 5. I use FilterOp on each row to see if I can keep it or not, and my table only has Strings and Floats in it, so I made an instance for each one. After finishing the conditions I have to write the evaluation for the data constructor but I'm not sure that part is correct either. The input will be something like this: Filter (Gt "Final grade" (read "5":: Float)) (FromCSV example_csv) .

type CSV = String
type Table = [[String]]

data Query = FromCSV CSV
    | ToCSV Query
    ...
    | forall a. FEval a => Filter (FilterCondition a) Query

data FilterCondition a =
    Eq String a |
    Lt String a |
    Gt String a

type FilterOp = Row -> Bool

class FEval a where
    feval :: [String] -> (FilterCondition a) -> FilterOp

-- This is what I have to do
instance FEval Float where
    ...
instance FEval String where
    ...

-- I'm not sure this is right
instance Filter (FilterCondition a) Query where
    ...

Answer 1

It's hard to give you specific advice but the problem was fun so I decided to show you what I consider close to your problem:

{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE ExistentialQuantification #-}
{-# LANGUAGE GADTs #-}

module Main where

import Data.List (intercalate)

main :: IO ()
main = putStrLn $ query exampleQuery

----------------------------------------------------------------------
-- Example

exampleCSV :: CSV
exampleCSV = "Name,Grade\nBob,5\nJill,2\nSandy,1"

-- > query exampleQuery
-- "Name,Grade\nJill,2\nSandy,1\n"
exampleQuery :: Query CSV
exampleQuery = ToCSV $ Filter (Lt "Grade" (5 :: Int)) $ FromCSV exampleCSV

----------------------------------------------------------------------
-- Types

-- | Query - a = result-type
data Query a where
    -- | query to turn a CSV into a table
    FromCSV :: CSV -> Query Table 
    -- | query to turn a table into a CSV
    ToCSV :: Query Table -> Query CSV
    -- | query to filter a table given a filter-condition
    Filter :: forall a. TableFilter a => FilterCondition a -> Query Table -> Query Table

type CSV = String

-- | Table holds rows (= list of values) and a list of column-names
data Table = Table [Row] [Column]
type Column = String
type Row = [String]

class TableFilter a where
    filterRow :: FilterCondition a -> [Column] -> Row -> Bool

data FilterCondition a 
    = Eq Column a
    | Lt Column a
    | Gt Column a

----------------------------------------------------------------------
-- Query

query :: Query a -> a
query (FromCSV csv) = fromCSV csv
query (ToCSV tableQuery) = toCSV (query tableQuery)
query (Filter cond tableQuery) = applyFilter cond (query tableQuery)

applyFilter :: TableFilter a => FilterCondition a -> Table -> Table
applyFilter cond (Table rows cols) = Table rows' cols
    where rows' = filter (filterRow cond cols) rows

fromCSV :: CSV -> Table
fromCSV = go . lines
    where
    go [] = error "cannot parse empty CSV - at least a header-line is needed"
    go [cols] = Table [] (splitOn ',' cols)
    go (cols:tbl) = Table rs cs
        where
        rs = map (splitOn ',') tbl
        cs = splitOn ',' cols

toCSV :: Table -> CSV
toCSV (Table rs cs) = 
    unlines $ intercalate "," cs : map (intercalate ",") rs

----------------------------------------------------------------------
-- TableFilter instances

instance TableFilter Int where
    filterRow = genFilterRow

instance TableFilter Float where
    filterRow = genFilterRow

genFilterRow :: (Ord a, Read a) => FilterCondition a -> [Column] -> Row -> Bool
genFilterRow cond cols row = 
    and $ zipWith (checkCond cond) cols row
    where
    checkCond (Eq condCol condVal) col val = condCol /= col || condVal == read val
    checkCond (Lt condCol condVal) col val = condCol /= col || condVal > read val
    checkCond (Gt condCol condVal) col val = condCol /= col || condVal < read val

----------------------------------------------------------------------
-- helpers
splitOn :: Eq a => a -> [a] -> [[a]]
splitOn c = go c []
    where
        go _ acc [] = [reverse acc]
        go c acc (y:ys)
            | c == y = reverse acc : go c [] ys
            | otherwise = go c (y:acc) ys

the real problem itself is probably encoded in genFilterRow - I had to do some guessing but I think the [String] argument in your description is actually the column-names . So this is just zipping them with the row-values and then using the FilterCondition together with read to filter on the matching column-name.

---

I did not know what output you expected so I used a GADT to get different outputs for different Query s (and made it impossible to do something like Filter (Lt "Grade" (5:: Int)) $ ToCSV $ FromCSV exampleCSV ).

The actual filtering can be made rather general ( genFilterRow = gen meaning generic ) - did not want to use undecidable instances so I think using this helper and the simple instance FilterTable is a good compromise.