----------------------------------------------------------------------
-- |
--模块：UseIO
--维修人员：AR
--稳定性：（稳定）
--便携性：（便携）
--
-->CVS$日期：2005/08/08 09:01:25$
-->CVS$作者：peb$
-->CVS$修订版：1.17$
--
--（模块说明）
-----------------------------------------------------------------------------

模块 GF.参考。UseIO（使用IO）(--**文件和IO
                      模块 GF.参考。UseIO（使用IO）,
                      --***重复使用
                      莫纳迪奥(..),提升错误) 哪里

进口 前奏曲 躲藏 (抓住)

进口 GF.数据。操作
进口 GF.参考。选项
进口 GF.系统。捕捉
进口 路径_gf(获取数据目录)

进口 GF.系统。号码簿
进口 系统。文件路径
进口 系统。IO（输入输出）
进口 系统。IO.错误(是用户错误,ioeGetErrorString（获取错误字符串）)
进口 系统。环境
进口 系统。出口
进口 系统。CPU时间
--导入系统。命令
进口 文本。打印
--进口管制。适用（适用（..））
进口 控制。莫纳德(什么时候,提升M,foldM（折叠M）)
进口 控制。莫纳德。变速箱(莫纳迪奥(..))
进口 控制。莫纳德。州(状态T,举起)
进口 控制。例外(评价)
进口 数据。列表 (节点)

--putIfVerb:：MonadIO io=>选项->字符串->io（）
putIfVerb:：选项->字符串->f（）putIfVerb（输入动词） 选项opts选项 字符串消息 = 布尔值->f（）->f（）对于所有（f:：*->*）。适用f=>Bool->f（）->f（）什么时候 (选项->详细->布尔verb至少 选项opts选项 详细详细) （f（）->f（））->f（）->f（）对于所有a b（a->b）->a->b$ 字符串->f（）所有（m:：*->*）。输出m=>字符串->m（）输入StrLnE 字符串消息

--***GF文件路径和库路径操作

类型 文件名 = 字符串
类型 初始路径 = 字符串 --^路径名的目录部分
类型 完整路径 = 字符串

gfLibraryPath:：字符串gf库路径    = 字符串“GF_LIB_PATH”
gfGrammarPathVar:：字符串gf语法路径变量 = 字符串“GF_语法_路径”

获取库目录 时间： 莫纳迪奥 国际奥委会 => 选项 -> 国际奥委会 [文件路径]
getLibraryDirectory:：Options->io[String]获取库目录 选项opts选项 =
  案例 （标志->可能[String]）->选项->可能[String]对于所有a.（标志->a）->选项->a旗帜 标志->可能[String]optGF库路径 选项opts选项 属于
    只是 [字符串]路径 -> [String]->io[String]对于所有（m:：*->*）a.Monad m=>a->ma返回 [字符串]路径
    也许[String]没有什么   -> （String->[String]）->io String->io[String]对于所有（m:：*->*）a1 r.Monad m=>（a1->r）->m a1->m r提升M 字符串->[字符串]分割搜索路径 （io字符串->io[String]）->io字符串->io[String]对于所有a b（a->b）->a->b$ IO字符串->IO字符串对于所有（m:：*->*）a.MonadIO m=>IO a->ma提升（liftIO） (IO字符串->（IOError->IO字符串）->IO字符串对于所有a.IO a->（IO错误->IO a）->IO a抓住 (字符串->IO字符串获取环境 字符串gf库路径)
                                                (\IO错误前 -> （字符串->字符串）->IO字符串->IO字符串对于所有（f:：*->*）a b.函数f=>（a->b）->fa->fb功能性维修计划 (字符串->字符串->字符串</> 字符串“库”) IO字符串获取数据目录))

获取语法路径 时间： 莫纳迪奥 国际奥委会 => [文件路径] -> 国际奥委会 [文件路径]
getGrammarPath:：[String]->io[String]获取语法路径 [字符串]库目录 = IO[String]->IO[String]对于所有（m:：*->*）a.MonadIO m=>IO a->ma提升（liftIO） （IO[String]->IO[String]）->IO[String]->IO[String对于所有a b（a->b）->a->b$ 做
  IO[String]->（IOError->IO[String]）->IO[字符串]对于所有a.IO a->（IO错误->IO a）->IO a抓住 (（字符串->[字符串]）->IO字符串->IO[字符串]对于所有（f:：*->*）a b.函数f=>（a->b）->fa->fb功能性维修计划 字符串->[字符串]分割搜索路径 （IO字符串->IO[字符串]）->IO字符串->IO[字符串]对于所有a b（a->b）->a->b$ 字符串->IO字符串获取环境 字符串gfGrammar路径变量) 
        (\IO错误_ -> [String]->IO[String]对于所有（m:：*->*）a.Monad m=>a->ma返回 （[字符串]->IO[字符串]）->[字符串]->IO[String]对于所有a b（a->b）->a->b$ [[String]]->[String]对于所有（t:：*->*）a.可折叠t=>t[a]->[a]凹面（concat） [[字符串库目录（_D） 字符串->字符串->字符串</> 字符串“所有时态”, 字符串库目录（_D） 字符串->字符串->字符串</> 字符串“序曲”]
                               | 字符串图书馆目录 <- [字符串]库目录 ])     --例如GF_GRAMMAR_PATH

--|使用扩展搜索路径
--“gfLibraryPath”和“gfGrammarPathVar”
--环境变量。仅返回现有路径。
扩展路径环境 时间： 莫纳迪奥 国际奥委会 => 选项 -> 国际奥委会 [文件路径]
extendPathEnv:：选项->io[String]扩展路径环境 选项opts选项 = IO[String]->IO[String]对于所有（m:：*->*）a.MonadIO m=>IO a->ma提升（liftIO） （IO[String]->IO[String]）->IO[String]->IO[String对于所有a b（a->b）->a->b$ 做
  让 opt_path:：[字符串]opt路径 = [字符串]->[字符串]对于所有a.等式a=>[a]->[a]节点 （[String]->[String]）->[String]->[Stringe]对于所有a b（a->b）->a->b$ （标志->[String]）->选项->[String]对于所有a.（标志->a）->选项->a旗帜 标志->[String]optLibraryPath 选项opts选项         --例如，作为选项提供的路径
  [字符串]库目录 <- 选项->IO[String]所有（io:：*->*）。MonadIO io=>选项->io[String]获取库目录 选项opts选项                  --例如GF_LIB_PATH
  [字符串]grm路径 <- [String]->IO[String]对于所有（io:：*->*）。MonadIO io=>[String]->io[String]获取语法路径 [字符串]库目录                   --例如GF_GRAMMAR_PATH
  让 路径：：[String]路径 = [字符串]opt路径 [String]->[String]->[String]对于所有a.[a]->[a]->[a]++ [字符串]库目录 [String]->[String]->[String]对于所有a.[a]->[a]->[a]++ [字符串]grm路径
  Bool->IO（）->IO（）对于所有（f:：*->*）。适用f=>Bool->f（）->f（）什么时候 (选项->详细->Boolverb至少 选项opts选项 详细详细) （IO（）->IO（））->IO对于所有a b（a->b）->a->b$ 字符串->IO（）输入StrLn (字符串“extendPathEnv:opt_path为”字符串->字符串->字符串对于所有a.[a]->[a]->[a]++ [String]->字符串for all a.显示a=>a->String显示 [字符串]opt路径)
  Bool->IO（）->IO（）对于所有（f:：*->*）。适用f=>Bool->f（）->f（）什么时候 (选项->详细->Bool动词至少 选项opts选项 详细详细) （IO（）->IO（））->IO对于所有a b（a->b）->a->b$ 字符串->IO（）输入StrLn (字符串“extendPathEnv:lib_dirs为”字符串->字符串->字符串对于所有a.[a]->[a]->[a]++ [String]->字符串for all a.显示a=>a->String显示 [字符串]库目录)
  Bool->IO（）->IO（）对于所有（f:：*->*）。适用f=>Bool->f（）->f（）什么时候 (选项->详细->Boolverb至少 选项opts选项 详细详细) （IO（）->IO（））->IO对于所有a b（a->b）->a->b$ 字符串->IO（）输入StrLn (字符串“extendPathEnv:grm_path为”字符串->字符串->字符串对于所有a.[a]->[a]->[a]++ [String]->字符串for all a.显示a=>a->String显示 [字符串]grm_路径)
  [字符串]秒 <- （[[String]]->[String]）->IO[[String]]->IO[String]对于所有（m:：*->*）a1 r.Monad m=>（a1->r）->m a1->m r提升M ([字符串]->[字符串]对于所有a.等式a=>[a]->[a]节点 （[字符串]->[字符串]）->（[[String]]->[String]）->[[String]]->[String]对于所有的b c a。（b->c）->（a->b）->a->c. [[String]]->[String]对于所有（t:：*->*）a.可折叠t=>t[a]->[a]凹面（concat）) （IO[[String]]->IO[String]）->IO[[字符串]]->IO[String]对于所有a b（a->b）->a->b$ （字符串->IO[字符串]）->[字符串]->IO[[字符串]]对于所有（t:：*->*）（m:：*->*）a b。（可通过t，单峰m）=>（a->m b）->t a->m（t b）地图M 字符串->IO[String]所有子目录 ([字符串]->[字符串]对于所有a.等式a=>[a]->[a]节点 [字符串]路径)
  （字符串->IO字符串）->[字符串]->IO[字符串]对于所有（t:：*->*）（m:：*->*）a b。（可通过t，单峰m）=>（a->m b）->t a->m（t b）地图M 字符串->IO字符串所有（m:：*->*）。MonadIO m=>字符串->m字符串canonicalizePath [字符串]秒
  哪里
    所有子目录 时间： 文件路径 -> IO（输入输出） [文件路径]
    allSubdirs:：字符串->IO[String]所有子目录 [] = [String]->IO[String]对于所有（m:：*->*）a.Monad m=>a->ma返回 [[]]
    所有子目录 字符串第页 = 案例 字符串->字符对于所有a.[a]->a最后的 字符串第页 属于
      烧焦'*' -> 做 让 路径：：字符串路径 = 字符串->字符串对于所有a.[a]->[a]初始化 字符串第页
                [字符串]英尺 <- 字符串->IO[String]获取子目录 字符串路径
                让 星形路径：：[String]恒星路径 = [字符串路径 字符串->字符串->字符串</> 字符串（f） | 字符串（f） <- [字符串]英尺]
                Bool->IO（）->IO（）对于所有（f:：*->*）。适用f=>Bool->f（）->f（）什么时候 (选项->详细->Boolverb至少 选项opts选项 详细详细) （IO（）->IO（））->IO对于所有a b（a->b）->a->b$ 字符串->IO（）输入StrLn (字符串“extendPathEnv:allSubdirs:*已找到”字符串->字符串->字符串对于所有a.[a]->[a]->[a]++[String]->字符串for all a.显示a=>a->String显示 [字符串]星光大道)
                [String]->IO[String]对于所有（m:：*->*）a.Monad m=>a->ma返回 [字符串]恒星路径
      烧焦_   -> 做 布尔存在 <- 字符串->IO Bool所有（m:：*->*）。MonadIO m=>字符串->m Bool目录是否存在 字符串第页
                如果 布尔存在
                  然后 做
                       Bool->IO（）->IO（）对于所有（f:：*->*）。适用f=>Bool->f（）->f（）什么时候 (选项->详细->Boolverb至少 选项opts选项 详细程度详细) （IO（）->IO（））->IO对于所有a b（a->b）->a->b$ 字符串->IO（）输入StrLn (字符串“extendPathEnv:allSubdirs:找到的路径”字符串->字符串->字符串对于所有a.[a]->[a]->[a]++字符串->字符串for all a.显示a=>a->String显示 字符串第页)
                       [String]->IO[String]对于所有（m:：*->*）a.Monad m=>a->ma返回 [字符串第页]
                  其他的 做 Bool->IO（）->IO（）对于所有（f:：*->*）。适用f=>Bool->f（）->f（）什么时候 (选项->详细->Boolverb至少 选项opts选项 详细详细) （IO（）->IO（））->IO对于所有a b（a->b）->a->b$ 字符串->IO（）输入StrLn (字符串“extendPathEnv:allSubdirs:忽略路径”字符串->字符串->字符串对于所有a.[a]->[a]->[a]++ 字符串->字符串for all a.显示a=>a->字符串显示 字符串第页)
                          [String]->IO[String]对于所有（m:：*->*）a.Monad m=>a->ma返回 []

获取子目录 时间： 文件路径 -> IO（输入输出） [文件路径]
getSubdirs:：String->IO[String]获取子目录 字符串目录 = 做
  [字符串]英尺  <- IO[String]->（IOError->IO[String]）->IO[字符串]对于所有a.IO a->（IO错误->IO a）->IO a抓住 (字符串->IO[String]所有（m:：*->*）。MonadIO m=>字符串->m[String]获取目录内容 字符串目录) (IO[String]->IO错误->IO[String]对于所有a b.a->b->a常数 （IO[String]->IOError->IO[String]）->IO[String]->IO错误->IO[String]对于所有a b（a->b）->a->b$ [String]->IO[String]对于所有（m:：*->*）a.Monad m=>a->ma返回 [])
  （[String]->String->IO[String]）->[String]->[String]->IO[String'对于所有（t:：*->*）（m:：*->*）b a。（可折叠t，单体m）=>（b->a->mb）->b->ta->mbfoldM（折叠M） (\[字符串]英尺 字符串（f） -> 做 让 fpath:：字符串fpath（fpath） = 字符串目录 字符串->字符串->字符串</> 字符串（f）
                     权限第页 <- 字符串->IO权限所有（m:：*->*）。MonadIO m=>字符串->m权限获取权限 字符串fpath（fpath）
                     如果 权限->Bool可搜索的 权限第页 Bool->Bool->Bool&& 布尔->布尔不 (Int->字符串->字符串对于所有a.国际->[a]->[a]拿 国际1 字符串（f）字符串->字符串->布尔对于所有a.等式a=>a->a->Bool==字符串".")
                       然后 [String]->IO[String]对于所有（m:：*->*）a.Monad m=>a->ma返回 (字符串fpath（fpath）字符串->[String]->[String]对于所有a.a->[a]->[a]:[字符串]英尺)
                       其他的 [String]->IO[String]对于所有（m:：*->*）a.Monad m=>a->ma返回        [字符串]英尺 ) [] [字符串]英尺

--------------------------------------------------------------------------------
仅模块名称 时间： 文件路径 -> 字符串
justModuleName:：String->String仅模块名称 = 字符串->字符串拖放扩展 （字符串->字符串）->（字符串->串）->字符串->字符串对于所有的b c a。（b->c）->（a->b）->a->c. 字符串->字符串take文件名

isGF公司,isGFO公司 时间： 文件路径 -> 布尔
isGF:：字符串->布尔isGF公司  = (字符串->字符串->Bool对于所有a.等式a=>a->a->Bool== 字符串“.gf”)  （字符串->布尔）->（字符串->字符串）->字符串->布尔对于所有的b c a。（b->c）->（a->b）->a->c. 字符串->字符串take扩展
isGFO：：字符串->布尔isGFO公司 = (字符串->字符串->Bool对于所有a.等式a=>a->a->Bool== 字符串“.gfo”) （字符串->布尔）->（字符串->字符串）->字符串->布尔对于所有的b c a。（b->c）->（a->b）->a->c. 字符串->字符串take扩展

gf文件,gfo文件 时间： 文件路径 -> 文件路径
gfFile:：String->字符串gfFile（gf文件）  字符串（f） = 字符串->字符串->字符串添加扩展名 字符串（f） 字符串“gf”
gfoFile:：String->Stringgfo文件 字符串（f） = 字符串->字符串->字符串添加扩展名 字符串（f） 字符串“gfo”

绿色荧光粉 时间： 选项 -> 文件路径 -> 文件路径
gf2gfo:：选项->字符串->字符串绿色荧光粉 = 可能是字符串->字符串->字符串gf2gfo' （可能是字符串->字符串->字符串）->（选项->可能是字符串）->选项->字符串->字符串对于所有的b c a。（b->c）->（a->b）->a->c. （标志->可能字符串）->选项->可能字符串对于所有a.（标志->a）->选项->a旗帜 标志->可能字符串optGFODir（操作GFODir）

gf2gfo'：：Maybe String->String->字符串gf2gfo' 也许是字符串gfo方向 字符串文件 = 字符串->（字符串->字符串）->也许字符串->字符串对于所有的ba.b->（a->b）->也许a->b也许 吧 (字符串->字符串gfo文件 (字符串->字符串拖放扩展 字符串文件))
                            (\字符串目录 -> 字符串目录 字符串->字符串->字符串</> 字符串->字符串gfo文件 (字符串->字符串takeBaseName（获取基本名称） 字符串文件))
                            也许是字符串gfo方向
--------------------------------------------------------------------------------
splitInModuleSearchPath（拆分模块搜索路径） 时间： 字符串 -> [文件路径]
splitInModuleSearchPath:：String->[String]拆分模块搜索路径 字符串秒 = 案例 （字符->Bool）->字符串->（字符串，字符串）对于所有a.（a->Bool）->[a]->（[a]，[a]）打破 字符->布尔isPathSep 字符串秒 属于
  (字符串（f）,烧焦_:字符串反恐精英) -> 字符串（f） 字符串->[String]->[String]对于所有a.a->[a]->[a]: 字符串->[字符串]拆分模块搜索路径 字符串反恐精英
  (字符串（f）,字符串_)    -> [字符串（f）]
  哪里
    isPathSep 时间： 烧焦 -> 布尔
    isPathSep:：Char->BoolisPathSep 烧焦c（c） = 烧焦c（c） 字符->字符->布尔对于所有a.等式a=>a->a->Bool== 烧焦':' 布尔->布尔->布尔|| 烧焦c（c） 字符->字符->布尔对于所有a.等式a=>a->a->Bool== 烧焦';'

--

--***IO monad中的错误处理

--|是：@newtype IOE a=IOE{appIOE:：IO（错误a）}@
类型 IOE公司 一 = IO（输入输出） 一

--ioe:：IO（错误a）->ioe a
--ioe-io=err失败返回=<<io

--|捕获由“IO”monad中的“raise”或“fail”调用引起的异常。
--要捕获所有“IO”异常，请改用“try”。
尝试IOE 时间： IOE公司 一 -> IO（输入输出） (错误 一)
tryIOE:：IOE a->IO（错误a）尝试IOE IOE公司a爱娥 = IO（Err a）->（字符串->IO（Er a））->IO（错误a）对于所有（m:：*->*）a。错误消息m=>ma->（字符串->ma）->ma手柄 (（a->错误a）->IOE a->IO（错误a）对于所有（f:：*->*）a b.函数f=>（a->b）->fa->fb功能性维修计划 a->错误a对于所有a.a->Err a好 啊 IOE公司a爱娥) (错误a->IO（错误a）对于所有（m:：*->*）a.Monad m=>a->ma返回 （错误a->IO（错误a））->（字符串->错误a）->字符串->IO（Err a）对于所有的b c a。（b->c）->（a->b）->a->c. 字符串->错误a对于所有a.字符串->错误a坏)

--运行IOE:：IOE a->IO a
--runIOE=id

--实例MonadIO IOE，其中liftIO io=IOE（io>>=return.return）

--|使raise和处理模拟旧IOE monad的行为
实例 错误消息 IO（输入输出） 哪里
  提升：：String->IO提升 = 字符串->IO a对于所有（m:：*->*）a.MonadFail m=>String->m a失败
  句柄：：IO a->（字符串->IO a）->IO a手柄 IO a（输入输出）米 字符串->IO a小时 = IO a->（IO错误->IO a）->IO a对于所有a.IO a->（IO错误->IO a）->IO a抓住 IO a（输入输出）米 （（IOError->IO a）->IO a）->（IOError->IO a）->IO a对于所有a b（a->b）->a->b$ \ IO错误e（电子） -> 如果 IO错误->Bool是用户错误 IO错误e（电子）
                                然后 字符串->IO a小时 (IOError->字符串ioeGetErrorString（获取错误字符串） IO错误e（电子）)
                                其他的 IO错误->IO a对于所有a.IO错误->IO aIO错误 IO错误e（电子）
{---控制。莫纳德。失败导入在GHC 8.8中将成为冗余+导入合格的控件。莫纳德。失败即失败实例Functor IOE，其中fmap=liftM实例适用IOE，其中纯=返回（<*>）=ap实例Monad IOE，其中return a=ioe（return（返回a））IOE c>>=f=IOE$dox<-c--错误aappIOE$err提升f x--f:：a->IOE a#如果！（最小版本基础（4,13,0））失败=升高#结尾实例失败。MonadFail IOE，其中失败=升高-}

--|如果IO操作“失败”，打印错误消息并返回默认值
使用IOE 时间： 一 -> 爱荷华州 一 -> IO（输入输出） 一
useIOE:：a->IOE a->IOEa使用IOE 一一 IOE公司a爱荷华州 = IOE a->（字符串->IOE a）->IOE a对于所有（m:：*->*）a。错误消息m=>ma->（字符串->ma）->ma手柄 IOE公司a爱娥 (\字符串秒 -> 字符串->IO（）输入StrLn 字符串秒 IO（）->IOE a->IOE a对于所有（m:：*->*）a b.Monad m=>m a->m b->m b>> a->IOE a对于所有（m:：*->*）a.Monad m=>a->ma返回 一一)

maybeIO:：IO a->f（可能是a）可能是IO IO a（输入输出）国际奥委会 = （IO错误->可能a）->（a->可能a）->任一IOError a->可能对于所有c b（a->c）->（b->c）->b->c中的任何一个任何一个 (可能是->IO错误->可能是对于所有a b.a->b->a常数 也许是一个对所有人来说。也许是没有什么) a->也许是对于所有a.a->可能是只是 （IO错误a->可能a）->f（任一IO错误a）->f（可能a）对于所有（f:：*->*）a b.函数f=>（a->b）->fa->fb`功能性维修计划` IO（任一IO错误a）->f（任一IOError a）对于所有（m:：*->*）a.MonadIO m=>IO a->ma提升（liftIO） (IO a->IO（IOError a之一）对于所有a.IO a->IO（任一IO错误a）尝试 IO a（输入输出）国际奥委会)
{---foldIOE:：（a->b->IOE a）->a->[b]->IOE（a，也许是字符串）foldIOE f s xs=的案例xs[]->返回，无内容x： xx->做ev<-升降IO$appIOE（f s x）案例ev确定v->foldIOE f v xx错误的m->返回$（s，仅m）-}
死亡 时间： 字符串 -> IO（输入输出） 一
die:：String->IO输入输出死亡 字符串秒 = 做 句柄->字符串->IO（）hPutStrLn公司 把手标准错误 字符串秒
           IO a（输入输出）对于所有a.IO a退出失败

--***诊断输出

班 莫纳德 米 => 输出 米 哪里
  电子输出Str, 电子输出StrLn, putStrE（输入StrE）, 输入StrLnE 时间： 字符串 -> 米 ()

实例 输出 IO（输入输出） 哪里
  ePutStr:：字符串->IO（）电子输出Str   字符串秒 = 句柄->字符串->IO（）hPutStr（推进器） 把手标准错误 字符串秒 IO（）->（IOError->IO（））->IO（）对于所有a.IO a->（IO错误->IO a）->IO a`捕捉` IO错误->IO（）对于所有（m:：*->*）p.Monad m=>p->m（）哎呀
    哪里 oops:：p->m（）哎呀 第页_ = （）->m（）对于所有（m:：*->*）a.Monad m=>a->ma返回 () --防止字符编码问题崩溃
  ePutStrLn：：字符串->IO（）电子输出StrLn 字符串秒 = 句柄->字符串->IO（）hPutStrLn公司 把手标准错误 字符串秒 IO（）->（IOError->IO（））->IO（）对于所有a.IO a->（IO错误->IO a）->IO a`捕获` IO错误->IO（）对于所有（m:：*->*）p.输出m=>p->m（）哎呀
    哪里 oops:：p->m（）哎呀 第页_ = 字符串->m（）所有（m:：*->*）。输出m=>字符串->m（）电子输出StrLn 字符串"" --防止字符编码问题崩溃
  putStrLnE:：字符串->IO（）输入StrLnE 字符串秒 = 字符串->IO（）输入StrLn 字符串秒 IO（）->IO（）->IO（）对于所有（m:：*->*）a b.Monad m=>m a->m b->m b>> 句柄->IO（）h冲洗 把手标准输出
  putStrE:：字符串->IO（）putStrE（输入StrE）   字符串秒 = 字符串->IO（）putStr（输入Str） 字符串秒 IO（）->IO（）->IO（）对于所有（m:：*->*）a b.Monad m=>m a->m b->m b>> 句柄->IO（）h冲洗 把手标准输出
{-实例输出IOE，其中ePutStr=liftIO。电子输出StrePutStrLn=提升IO。电子输出StrLnputStrLnE=liftIO。输入StrLnEputStrE=liftIO。putStrE（输入StrE）-}

实例 输出 米 => 输出 (状态T 秒 米) 哪里
  ePutStr:：字符串->状态T s m（）电子输出 = m（）->状态T s m（）对于所有（t:：（*->*）->*->x）（m:：*.>*）a。（单反式t，单反式m）=>m a->t m a举起 （m（）->州T s m（））->（字符串->m（））->字符串->状态T s m（）对于所有的b c a。（b->c）->（a->b）->a->c. 字符串->m（）所有（m:：*->*）。输出m=>字符串->m（）电子输出Str
  ePutStrLn：：字符串->状态T s m（）电子输出导线 = m（）->状态T s m（）对于所有（t:：（*->*）->*->x）（m:：*.>*）a。（单反式t，单反式m）=>最大值->最大值举起 （m（）->州T s m（））->（字符串->m（））->字符串->状态T s m（）对于所有的b c a。（b->c）->（a->b）->a->c. 字符串->m（）所有（m:：*->*）。输出m=>字符串->m（）电子输出StrLn
  putStrE:：String->StateT s m（）putStrE（输入StrE） = m（）->状态T s m（）对于所有（t:：（*->*）->*->x）（m:：*.>*）a。（单反式t，单反式m）=>最大值->最大值举起 （m（）->州T s m（））->（字符串->m（））->字符串->状态T s m（）对于所有的b c a。（b->c）->（a->b）->a->c. 字符串->m（）所有（m:：*->*）。输出m=>字符串->m（）putStrE（输入StrE）
  putStrLnE:：字符串->状态T s m（）输入StrLnE = m（）->状态T s m（）对于所有（t:：（*->*）->*->x）（m:：*.>*）a。（MonadTrans t，Monad m）=>最大值->最大值举起 （m（）->州T s m（））->（字符串->m（））->字符串->状态T s m（）对于所有的b c a。（b->c）->（a->b）->a->c. 字符串->m（）所有（m:：*->*）。输出m=>字符串->m（）输入StrLnE

--putPointE:：详细->选项->字符串->IO a->IO a
putPointE:：详细->选项->字符串->m b->m b输入点E 详细v（v） 选项opts选项 字符串消息 百万桶行为 = 做
  Bool->m（）->m（）对于所有（f:：*->*）。适用f=>Bool->f（）->f（）什么时候 (选项->详细->Boolverb至少 选项opts选项 详细v（v）) （m（）->m（））->m（）->m（）对于所有a b（a->b）->a->b$ 字符串->m（）所有（m:：*->*）。输出m=>字符串->m（）putStrE（输入StrE） 字符串消息

  (整数t吨,b条一) <- m b->m（整数，b）对于所有（m:：*->*）b.MonadIO m=>m b->m（整数，b）timeIt时间 百万桶行为

  如果 （标志->Bool）->选项->Bool对于所有a.（标志->a）->选项->a旗帜 标志->BooloptShowCPUTime（选择显示CPU时间） 选项opts选项
      然后 做 让 毫秒：：整数毫秒 = 整数t吨 整数->整数->整数对于所有a，积分a=>a->a->a->a`div公司` 整数1000000000
              字符串->m（）所有（m:：*->*）。输出m=>字符串->m（）输入StrLnE (字符串->整数->字符串对于所有r.PrintfType r=>String->r打印 字符串“%5d毫秒” 整数毫秒)
      其他的 Bool->m（）->m（）对于所有（f:：*->*）。适用f=>Bool->f（）->f（）什么时候 (选项->详细->Boolverb至少 选项opts选项 详细v（v）) （m（）->m（））->m（）->m（）对于所有a b（a->b）->a->b$ 字符串->m（）所有（m:：*->*）。输出m=>字符串->m（）输入StrLnE 字符串""

  b->m b对于所有（m:：*->*）a.Monad m=>a->ma返回 b条一

--|因为GHC为以下原因导致的故障添加了令人困惑的文本“用户错误”
--调用“失败”。
ioErrorText:：IOError->字符串io错误文本 IO错误e（电子） = 如果 IO错误->Bool是用户错误 IO错误e（电子）
                然后 IOError->字符串ioeGetErrorString（获取错误字符串） IO错误e（电子）
                其他的 IOError->字符串for all a.显示a=>a->字符串显示 IO错误e（电子）

--***计时

timeIt:：m b->m（整数，b）时间它 百万桶行为 =
  做 整数t1时间 <- IO整数->m整数对于所有（m:：*->*）a.MonadIO m=>IO a->ma提升（liftIO） （IO整数->m整数）->IO整数->m整数对于所有a b（a->b）->a->b$ IO整数获取CPU时间
     b条一 <- IO b->m b对于所有（m:：*->*）a.MonadIO m=>IO a->ma提升（liftIO） （IO b->m b）->（b->IO b）->b->m b对于所有的b c a。（b->c）->（a->b）->a->c. b->IO b对于所有a.a->IO a评价 （b->mb）->mb->mb对于所有（m:：*->*）a b.Monad m=>（a->mb）->ma->mb=<< 百万桶行为
     整数t2时间 <- IO整数->m整数对于所有（m:：*->*）a.MonadIO m=>IO a->ma提升（liftIO） （IO整数->m整数）->IO整数->m整数对于所有a b（a->b）->a->b$ IO整数获取CPU时间
     （整数，b）->m（整数，b）对于所有（m:：*->*）a.Monad m=>a->ma返回 (整数t2时间整数->整数->整数对于所有a.数字a=>a->a->a-整数t1时间,b条一)

--***文件IO

写入UTF8文件 时间： 文件路径 -> 字符串 -> IO（输入输出） ()
writeUTF8文件：：String->String->IO（）写入UTF8文件 字符串fpath（路径） 字符串内容 =
  字符串->IOMode->（句柄->IO（））->IO（）对于所有r.字符串->IOMode->（句柄->IO r）->IO r使用文件 字符串fpath（路径） IOMode（IOM模式）写方式 （（句柄->IO（））->IO（对于所有a b（a->b）->a->b$ \ 把手小时 -> 做 句柄->文本编码->IO（）hSet编码 把手小时 文本编码utf8接口
                                       句柄->字符串->IO（）hPutStr（推进器） 手柄小时 字符串内容

readBinaryFile:：String->IO字符串读取二进制文件 字符串路径 = 句柄->IO字符串hGetContents（获取内容） （句柄->IO字符串）->IO句柄->IO串对于所有（m:：*->*）a b.Monad m=>（a->mb）->ma->mb=<< 字符串->IOMode->IO句柄打开二进制文件 字符串路径 IOMode（IOM模式）ReadMode（读取模式）
writeBinaryFile:：String->String->IO（）写入二进制文件 字符串路径 字符串秒 = 字符串->IOMode->（句柄->IO（））->IO（）对于所有r.字符串->IOMode->（句柄->IO r）->IO r带二进制文件 字符串路径 IOMode（IOM模式）写方式 (（Handle->String->IO（））->String->Handle->IO（）对于所有a到b到c（a到>b到>c）->b到>a到>c轻弹 句柄->字符串->IO（）hPutStr（推进器） 字符串秒)