Question

我有一个使用UU.Parsing lib读取文件和解析的代码，它返回一个抽象的sintax树并在屏幕上显示。

我在 tokensParserToByteString 和 applyParser 的功能中使用 parseIO （UU.Parsing）收到错误消息“No instance for Show” lib）并继承签名直到main。我修复了签名，但我的问题出在主函数中。我在签名中添加了实例Show，但我有下一个编译错误：

No instance for (Show (IO J2s)) arising from a use of ‘main’
In the expression: main
When checking the type of the IO action ‘main’

完整的错误消息是：

$ cabal build
Building java2scala-1.0...
Preprocessing library java2scala-1.0...
In-place registering java2scala-1.0...
Preprocessing executable 'java2scala' for java2scala-1.0...
Preprocessing executable 'test' for java2scala-1.0...
[5 of 5] Compiling Main             ( test/Main.hs, dist/build/test/test-tmp/Main.o )

test/Main.hs:27:1:
    No instance for (Show (IO J2s)) arising from a use of ‘main’
    In the expression: main
    When checking the type of the IO action ‘main’

关于这个问题的一些想法？

主要模块

{-# LANGUAGE FlexibleContexts #-}
module Main where

import UU.Parsing
...
import Content

main :: (Show (IO J2s)) => IO()
main = do f <- getLine
      let command = test f
      command

test :: (Show (IO J2s)) => String -> IO()
test "testparser" = testParser

测试模块

{-# LANGUAGE FlexibleContexts #-}
module J2s.Parser.Test where

import Content
import J2s.Ast.Sintax
import J2s.Parser
import UU.Parsing
...

testParser :: (Show (IO J2s)) => IO()
testParser  = (runSafeIO $ runProxy $ runEitherK $
                contentsRecursive "path/of/my/tests" />/ handlerParser) :: (Show (IO J2s)) => IO()

内容模块

{-# LANGUAGE FlexibleContexts #-}
module Content where

import Control.Monad(forM, liftM)
import System.Directory (doesDirectoryExist, getDirectoryContents)
import System.FilePath ((</>), splitExtension, splitFileName)
import J2s.Parser
import J2s.Ast.Sintax
import UU.Parsing

import Control.Monad (when, unless)
import Control.Proxy
import Control.Proxy.Safe hiding (readFileS)

import J2s.Scanner.Token
import Text.Show

import UU.Parsing


contentsRecursive
     :: (CheckP p)
     => FilePath -> () -> Producer (ExceptionP p) FilePath SafeIO ()
contentsRecursive path () = loop path
   where
     loop path = do
         contents path () //> \newPath -> do
             respond newPath
             isDir <- tryIO $ doesDirectoryExist newPath
             let isChild = not $ takeFileName newPath `elem` [".", ".."]
             when (isDir && isChild) $ loop newPath


applyParser :: (Proxy p, Show (IO J2s)) => String -> Consumer p B.ByteString IO ()
applyParser path = runIdentityP loop
  where
    loop = do
        bs <- request ()
        let sc = classify  (initPos path) (B8.unpack bs)
        lift $  B8.putStrLn (tokensParserToByteString sc)

tokensParserToByteString :: (Show (IO J2s)) =>  [Token] -> B.ByteString
tokensParserToByteString tokens = B8.pack(show (parseIO pJ2s tokens))


handlerParser :: (CheckP p, Show (IO J2s)) => FilePath -> Session (ExceptionP p) SafeIO ()
handlerParser path = do
    canRead <- tryIO $ fmap readable $ getPermissions path
    isDir   <- tryIO $ doesDirectoryExist path
    isValidExtension <- tryIO $ evaluate ((snd (splitExtension path) == ".java" || snd (splitExtension path) == ".mora") && (snd (splitFileName path) /= "EncodeTest.java") && (snd (splitFileName path) /= "T6302184.java") && (snd (splitFileName path) /= "Unmappable.java"))
    when (not isDir && canRead && isValidExtension) $
        (readFileSP 10240 path >-> try . applyParser) path


readFileSP
:: (CheckP p)
=> Int -> FilePath -> () -> Producer (ExceptionP p) B.ByteString SafeIO ()
readFileSP chunkSize path () =
    bracket id (openFile path ReadMode) hClose $ \handle -> do
        let loop = do
                eof <- tryIO $ hIsEOF handle
                unless eof $ do
                    bs <- tryIO $ B.hGetSome handle chunkSize
                    respond bs
                    loop
        loop

Answer 1

像Show (IO J2s) => IO ()这样的签名几乎没有意义。这表达的基本上是“如果宇宙是精心设计的，IO J2s有一个Show实例，我会给你一个IO ()动作”。好吧，如果宇宙具有该属性，那么现在就给我们IO ()动作。 Keep nasty ~~chips~~constraints！
如果将约束应用于类型变量，那么约束才真正有意义，即如果你编写的多态性代码是几种不同的，而不是所有类型。（与CheckP p一样）。但是，应用于具体类型的约束只不过是推迟类型错误。

IO J2s 没有Show个实例。它不能有这样的实例：这是一个 IO动作。它可能是一个完整的子程序，可能执行昂贵的计算，调用商业第三方库代码，发射一些导弹......并且只在最后返回J2s值。您如何期望将可能复杂的东西的所有信息打包成一个简单的字符串？

Show实例的可能性是J2s。如果您仍然在IO monad并且有IO J2s操作，则可以通过monad绑定该操作（即执行）随时从中获取J2s值子程序）并只显示J2s值。在你的情况下：

tokensParserToByteString :: [Token] -> IO B.ByteString
tokensParserToByteString tokens = fmap (B8.pack . show) $ parseIO pJ2s tokens

我认为你对IO仿函数中的fmapping感到困惑，这相当于

tokensParserToByteString :: [Token] -> IO B.ByteString
tokensParserToByteString tokens = do
     j2sValue <- parseIO pJ2s tokens
     return . B8.pack $ show j2sValue

当然，您需要调整applyParser，因为tokensParserToByteString现在是IO操作。 =<< operator：

足够简单

applyParser :: Proxy p => String -> Consumer p B.ByteString IO ()
applyParser path = runIdentityP loop
  where
    loop = do
        bs <- request ()
        let sc = classify  (initPos path) (B8.unpack bs)
        lift $ B8.putStrLn =<< tokensParserToByteString sc

在“主要”级别中没有使用Show的实例

1 个答案: