弗雷格'；s相当于Haskell'；让我们来读一读

在标准库的控制台中，是否有类似于Haskell的

getLine

和

read

的Frege方法来解析输入

目前我是这样做的：

import frege.IO

getLine :: IO String
getLine = do
 isin <- stdin
 isrin <- IO.InputStreamReader.new isin
 brin <- IO.BufferedReader.fromISR isrin
 line <- brin.readLine
 return $ fromExceptionMaybe line

fromExceptionMaybe :: Exception (Maybe a) -> a
fromExceptionMaybe (Right (Just r)) = r
fromExceptionMaybe (Right _) = error "Parse error on input"
fromExceptionMaybe (Left l) = error l.getMessage

pure native parseInt java.lang.Integer.parseInt :: String -> Int

main _ = do
 line <- getLine
 println $ parseInt line

有关更多详细信息，请参见以下Ingo的回答。

更新：在更新版本的Frege中提供I/O支持 从3.21.80版开始，我们在标准库中有更好的I/O支持：

• 运行时提供

  stdout

  和

  stderr

  （缓冲，UTF8编码

  java.io.printWriter

  环绕

  java.lang.System.out

  和

  java.lang.System.err

  ）和

  stdin

  （UTF8解码

  java.io.BufferedReader

  环绕

  java.lang.System.in

  ）
• 函数

  print

  ，

  println

  ，

  putStr

  ，

  putChar

  写入

  stdout

• getChar

  和

  getLine

  从

  stdin

  读取，并在文件末尾抛出异常
• Java类（如

  PrintWriter

  、

  BufferedWriter

  等）的弗雷格等价物在模块

  Java.IO

  中定义，并自动导入。这样，就支持了更基本的功能。例如，

  BufferedReader.readLine

  的返回类型为

  IO（可能是字符串）

  ，并通过返回

  Nothing

  来发出文件结束的信号，与Java对应方类似，在这种情况下，Java对应方返回

  null

下面是一个实现基本grep的简短示例程序：

--- A simple grep
module examples.Grep where

--- exception thrown when an invalid regular expression is compiled
data PatternSyntax = native java.util.regex.PatternSyntaxException
derive Exceptional PatternSyntax

main [] = stderr.println "Usage: java examples.Grep regex [files ...]"
main (pat:xs) = do
        rgx <- return (regforce pat)
        case xs of
            [] -> grepit rgx stdin
            fs -> mapM_ (run rgx) fs
     `catch` badpat where
        badpat :: PatternSyntax -> IO ()
        badpat pse = do
            stderr.println "The regex is not valid."
            stderr.println pse.getMessage        

run regex file = do
        rdr <- utf8Reader file
        grepit regex rdr
    `catch` fnf where
        fnf :: FileNotFoundException -> IO ()
        fnf _ = stderr.println ("Could not read " ++ file)


grepit :: Regex -> BufferedReader -> IO ()                
grepit pat rdr = loop `catch` eof `finally` rdr.close 
    where
        eof :: EOFException -> IO ()
        eof _ = return ()
        loop = do
            line <- rdr.getLine 
            when (line ~ pat) (println line)
            loop

——一个简单的grep
模块示例。Grep在哪里
---编译无效正则表达式时引发异常
data PatternSyntax=本机java.util.regex.PatternSyntaxException
派生异常模式语法
main[]=stderr.println“用法：java示例.Grep regex[文件…””
main（pat:xs）=do
rgx grepit rgx stdin
fs->mapM(运行rgx）fs
`抓住巴德帕特在哪里
badpat:：模式语法->IO（）
badpat=do
stderr.println“正则表达式无效。”
stderr.println pse.getMessage
运行regex file=do
rdr IO（）
fnf_u2;=stderr.println（“无法读取”++文件）
grepit:：Regex->BufferedReader->IO（）
grepit pat rdr=loop`catch`eof`finally`rdr.close
哪里
eof:：EOFEException->IO（）
eof=返回（）
循环=do
行，我自由添加了一些标签。非常感谢。弗雷格正在取得巨大的进步，如果我能帮上什么忙，我会很乐意为之做出贡献。@Marimuthu-请给我发封邮件，你可以在弗雷格项目页面上找到我的地址。（找不到你的。）当然可以。BufferedReader类型具有readLine函数。
--- A simple grep
module examples.Grep where

--- exception thrown when an invalid regular expression is compiled
data PatternSyntax = native java.util.regex.PatternSyntaxException
derive Exceptional PatternSyntax

main [] = stderr.println "Usage: java examples.Grep regex [files ...]"
main (pat:xs) = do
        rgx <- return (regforce pat)
        case xs of
            [] -> grepit rgx stdin
            fs -> mapM_ (run rgx) fs
     `catch` badpat where
        badpat :: PatternSyntax -> IO ()
        badpat pse = do
            stderr.println "The regex is not valid."
            stderr.println pse.getMessage        

run regex file = do
        rdr <- utf8Reader file
        grepit regex rdr
    `catch` fnf where
        fnf :: FileNotFoundException -> IO ()
        fnf _ = stderr.println ("Could not read " ++ file)


grepit :: Regex -> BufferedReader -> IO ()                
grepit pat rdr = loop `catch` eof `finally` rdr.close 
    where
        eof :: EOFException -> IO ()
        eof _ = return ()
        loop = do
            line <- rdr.getLine 
            when (line ~ pat) (println line)
            loop