Markdown table parser

table.hs

{-# LANGUAGE OverloadedStrings #-}

module Table where

import           Control.Monad
import           Data.Attoparsec.Text as P
import           Data.Text            (Text)
import qualified Data.Text            as T

data Table = Table [Column]
    deriving Show

data Column = Column [Text]
    deriving Show

columnParser :: Parser Column
columnParser = do
    rest <- takeText
    go mempty rest
  where
    go :: [Text] -> Text -> Parser Column
    go currList curr = 
        flip either
            (\(currList', rest') -> do
                let symbolCount = T.length $ T.filter (== '|') rest'
                if T.null rest' || symbolCount < 2
                    then return $ Column currList'
                    else go currList' rest'
            ) 
            (\err -> fail err)
            (parseOnly (getElem currList) curr)

    getElem :: [Text] -> Parser ([Text], Text)
    getElem currList = do
        void $ P.char '|'
        element <- T.strip <$> P.takeWhile (/= '|')
        rest    <- takeText
        return $ ((currList ++ [element]), rest)

testColumnParser :: Either String Column
testColumnParser = parseOnly columnParser "| hello | this is | test |"

testTable :: [Text]
testTable = 
    [ "| hello | this is | test |"
    , "| 1 | 2 | 3 |"
    , "| a | b | c |"
    ]

parseTable :: [Text] -> Either String Table
parseTable texts = go (Table mempty) texts
  where
    go :: Table -> [Text] -> Either String Table
    go table []                = return table
    go (Table currList) (t:ts) = 
        either 
            (\a -> Left a) -- ????????
            (\column -> go (Table (currList <> [column])) ts)
            (parseOnly columnParser t)