1

我无法通过带有haskell-pipes的管道引导流量。基本上，我分析了一堆文件，然后我必须要么

  1. 以人性化的方式将结果打印到终端
  2. 将结果编码为 JSON

选择的路径取决于命令行选项。
在第二种情况下，我必须输出一个左括号，然后是每个传入的值，后跟一个逗号，然后是一个右括号。当前insertCommas从不终止，因此从不输出右括号。

import Pipes
import Data.ByteString.Lazy as B
import Data.Aeson (encode)

insertCommas :: Consumer B.ByteString IO ()
insertCommas = do
    first <- await
    lift $ B.putStr first
    for cat $ \obj -> lift $ do
        putStr ","
        B.putStr obj

jsonExporter :: Consumer (FilePath, AnalysisResult) IO ()
jsonExporter = do
    lift $ putStr "["
    P.map encode >-> insertCommas
    lift $ putStr "]"

exportStream :: Config -> Consumer (FilePath, AnalysisResult) IO ()
exportStream conf =
    case outputMode conf of
      JSON -> jsonExporter
      _    -> P.map (export conf) >-> P.stdoutLn

main :: IO ()
main = do
    -- The first two lines are Docopt stuff, not relevant
    args <- parseArgsOrExit patterns =<< getArgs
    ins  <- allFiles $ args `getAllArgs` argument "paths"
    let conf = readConfig args
    runEffect $ each ins
             >-> P.mapM analyze
             >-> P.map (filterResults conf)
             >-> P.filter filterNulls
             >-> exportStream conf
4

2 回答 2

3

AFAIK 消费者无法检测到流的结束。为此，您需要使用 Pipes.Parser 并反转控件。

这是一个在 String 元素之间插入逗号的 Parser：

import Pipes
import qualified Pipes.Prelude as P
import Pipes.Parse (draw, evalStateT)

commify = do
  lift $ putStrLn "["
  m1 <- draw
  case m1 of
    Nothing -> lift $ putStrLn "]"
    Just x1 -> do
      lift $ putStrLn x1
      let loop = do mx <- draw
                    case mx of
                      Nothing -> lift $ putStrLn "]"
                      Just x  -> lift (putStr "," >> putStrLn x) >> loop
      loop

test1 = evalStateT commify ( mapM_ yield (words "this is a test") )
test2 = evalStateT commify P.stdinLn

为了处理不同的输出格式，我可能会将这两种格式都设为 Parser：

exportParser = do
  mx <- draw
  case mx of
    Nothing -> return ()
    Just x  -> (lift $ putStrLn $ export x) >> exportParser

进而：

let parser = case outputMode of
               JSON -> commify
               _    -> exportParser
evalStateT parser (P.mapM analyze
                      >-> P.map (filterResults conf)
                      >-> P.filter filterNulls)

可能有一种更巧妙的方式来exportParser编写foldAllM. 您还可以使用MaybeT转换器更简洁地编写commify解析器。我已经明确地写出来了，以使它们更容易理解。

于 2015-11-01T17:17:51.963 回答
1

我认为您应该与管道组“妥协”。它有一个intercalates，但没有穿插，但写起来没什么大不了的。我认为，对于此类问题，您应该远离消费者端。

{-#LANGUAGE OverloadedStrings #-}
import Pipes
import qualified Pipes.Prelude as P
import qualified Data.ByteString.Lazy.Char8 as B
import Pipes.Group
import Lens.Simple  -- or Control.Lens or Lens.Micro or anything with view/^.
import System.Environment

intersperse_ :: Monad m => a -> Producer a m r -> Producer a m r
intersperse_ a producer = intercalates (yield a) (producer ^. chunksOf 1) 

main = do 
  args <- getArgs
  let op prod = case args of 
        "json":_ -> yield "[" *> intersperse_ "," prod <* yield "]"
        _        -> intersperse_ " " prod
  runEffect $ op producer >-> P.mapM_ B.putStr
  putStrLn ""
  where 
    producer = mapM_ yield (B.words "this is a test")

这给了我这个

    >>> :main json
    [this,is,a,test]
    >>> :main ---
    this is a test
于 2015-11-01T19:49:33.880 回答