如何使用GHC API动态编译并导入一个模块 – LTS Haskell 20.20（ghc-9.2.7）？

huangapple
go评论117阅读模式
英文:

How to dynamically compile and import a module using GHC API - LTS Haskell 20.20 (ghc-9.2.7)?

问题

背景

我想在Haskell中实现一个程序，该程序可以动态生成Haskell模块（hs-文件），然后编译并将其导入到生成代码的同一应用程序中。

因此，我尝试理解Stack Overflow和文档中的一些示例代码片段。但它既不能工作也不能编译。

在对给定示例的某些修改之后，我创建了以下源代码Main.hs：

  1. import qualified GhcApiWrap as Ghw
  3. main :: IO ()
  4. main = Ghw.msLoadModuleAndExecute "../dyn/" "DynExample.hs" "nFromChar" 'A'

GhcApiWrap.hs：

  1. module GhcApiWrap
  2.     (
  3.         msLoadModuleAndExecute
  4.     ) where
  6. import GHC
  8. msLoadModuleAndExecute :: String -> String -> String -> Char -> IO ()
  9. msLoadModuleAndExecute _ _ _ _ = do
  10.     value' <- runGhc (Just "./src/") $ do
  11.             dflags <- getSessionDynFlags
  12.             setSessionDynFlags $ dflags { 
  13.                 ghcLink   = LinkInMemory, 
  14.                 ghcMode = CompManager,
  15.                 objectDir   = Just "../dyn/",
  16.                 hiDir   = Just "../dyn/"
  17.                 }
  18.             target <- guessTarget "DynExample.hs" Nothing
  19.             setTargets [target]
  20.             ret <- load LoadAllTargets
  21.             case ret of
  22.                 Succeeded -> do
  23.                     importDecl_RdrName <- parseImportDecl "import DynExample"
  24.                     setContext [IIDecl importDecl_RdrName]
  26.                     value <- dynCompileExpr "DynExample.nFromChar"
  28.                     return value
  29.                 _       -> 
  30.                     return undefined
  31.     print $ value'

DynExample.hs：

  1. module DynExample
  2.     (
  3.         nFromChar
  4.     ) where
  6. nFromChar :: Char -> Int
  7. nFromChar _ = 33

... 这个程序能够编译但无法工作。

它的输出是：

  1. ExprmntGhcApi-exe: Missing file: src/settings

如您所见，我注释掉了 import GHC.Paths (libdir)，因为它不再存在。因此，我谨慎地猜测，我使用了 (Just "./src/") 代替了 (Just libdir)。

我尝试了几个版本，但没有一个能与GHC 9.2.7一起工作。

问题

是否可以使用最新的Haskell Stack环境以及以下函数类型，以动态方式使用 DynExample.nFromChar 这种方式？

  1. msLoadModuleAndExecute :: String -> String -> String -> Char -> ... Int

环境

目前，我正在使用带有以下配置的Stack：

  1. resolver:
  2.   url: https://raw.githubusercontent.com/commercialhaskell/stackage-snapshots/master/lts/20/20.yaml

... 这对应于使用GHC 9.2.7。

英文:

Background

I would like to implement a program in Haskell that can generate Haskell module (hs-File) dynamically and then compile, and import it into the same application that generated the code.

Therefore, I tried to understand some example code snippets in SO and documentation. But it doesn't work nor compiles.

After some modifications of one of the given examples, I created the following souce code, Main.hs:

  1. import qualified GhcApiWrap as Ghw
  3. main :: IO ()
  4. main = Ghw.msLoadModuleAndExecute &quot;../dyn/&quot; &quot;DynExample.hs&quot; &quot;nFromChar&quot; &#39;A&#39;

GhcApiWrap.hs:

  1. module GhcApiWrap
  2.     (
  3.         msLoadModuleAndExecute
  4.     ) where
  6. import GHC
  7. --import GHC.Paths (libdir)  
  9. msLoadModuleAndExecute :: String -&gt; String -&gt; String -&gt; Char -&gt; IO ()
  10. msLoadModuleAndExecute _ _ _ _ = do
  11.     value&#39; &lt;- runGhc (Just &quot;./src/&quot;) $ do
  12.             dflags &lt;- getSessionDynFlags
  13.             setSessionDynFlags $ dflags { 
  14.                 ghcLink   = LinkInMemory, 
  15.                 ghcMode = CompManager,
  16.                 objectDir   = Just &quot;../dyn/&quot;,
  17.                 hiDir   = Just &quot;../dyn/&quot;
  18.                 }
  19.             target &lt;- guessTarget (&quot;DynExample.hs&quot;) Nothing
  20.             setTargets [target]
  21.             ret &lt;- load LoadAllTargets
  22.             case ret of
  23.                 Succeeded -&gt; do
  24.                     importDecl_RdrName &lt;- parseImportDecl $ &quot;import DynExample&quot;
  25.                     setContext [IIDecl importDecl_RdrName]
  27.                     value &lt;- dynCompileExpr (&quot;DynExample.nFromChar&quot;)
  29.                     return value
  30.                 _       -&gt; 
  31.                     return undefined
  32.     print $ value&#39;

DynExample.hs:

  1. module DynExample
  2.     (
  3.         nFromChar
  4.     ) where
  6. nFromChar :: Char -&gt; Int
  7. nFromChar _ = 33

...which compiles but doesn't work.

Its ouput is:

  1. ExprmntGhcApi-exe: Missing file: src/settings

As you can see, I commented out import GHC.Paths (libdir) because it doesn't exist anymore. Therefore, as a humble guess I used (Just &quot;./src/&quot;) instead of (Just libdir).

I tried several versions that are "flying around", but none of them work with GHC 9.2.7.

Question

Is it, and how is it possible to use DynExample.nFromChar dynamically this way using an up-to-date Haskell Stack environment, and having the following type of the function?

  1. msLoadModuleAndExecute :: String -&gt; String -&gt; String -&gt; Char -&gt; ... Int

Environment

At the moment, I am using Stack with:

  1. resolver:
  2.   url: https://raw.githubusercontent.com/commercialhaskell/stackage-snapshots/master/lts/20/20.yaml

...which translates to usage of GHC 9.2.7.

答案1

得分: 2

所以，通过添加对ghc-paths包的依赖，解决了import GHC.Paths (libdir)的问题。

接下来的问题是正确地为guessTarget提供参数。从文档中可以看到：

尝试猜测字符串引用的目标是什么。这个函数实现了--make/GHCi命令行语法用于文件名。

因此，需要提供模块的路径而不仅仅是名称。

最后的问题是，dynCompileExpr返回一个Dynamic对象，应该将其转换为您的函数类型Char -> Int，然后进行计算。

将所有这些组合起来，我们可以得到：

  1. module GhcApiWrap
  2.     (
  3.         msLoadModuleAndExecute
  4.     ) where
  6. import Control.Exception.Safe
  7. import Data.Dynamic
  8. import GHC
  9. import GHC.Paths (libdir)
  10. import System.FilePath
  12. msLoadModuleAndExecute :: FilePath -> FilePath -> String -> Char -> IO Int
  13. msLoadModuleAndExecute buildDir modulePath funcName arg = do
  14.     dynFunc <- runGhc (Just libdir) $ do
  15.         dflags <- getSessionDynFlags
  16.         setSessionDynFlags $ dflags { ghcLink   = LinkInMemory
  17.                                     , ghcMode   = CompManager
  18.                                     , objectDir = Just buildDir
  19.                                     , hiDir     = Just buildDir
  20.                                     }
  21.         target <- guessTarget modulePath Nothing
  22.         setTargets [target]
  23.         loadStatus <- load LoadAllTargets
  24.         case loadStatus of
  25.             Succeeded -> do
  26.                 let moduleName = dropExtension $ takeFileName modulePath
  27.                 importDecl_RdrName <- parseImportDecl $ "import " ++ moduleName
  28.                 setContext [IIDecl importDecl_RdrName]
  29.                 dynCompileExpr $ moduleName ++ "." ++ funcName
  30.             Failed    -> throwString $ "could not load the module: " ++ modulePath
  31.     case fromDynamic dynFunc of
  32.         Just func -> pure $ func arg
  33.         Nothing   -> throwString $ funcName ++ " has type '" ++ show dynFunc ++ "' but expected type `Char -> Int'"

可以通过以下方式运行它：

  1. import qualified GhcApiWrap as Ghw
  3. main :: IO ()
  4. main = print =<< Ghw.msLoadModuleAndExecute "../dyn/" "DynExample.hs" "nFromChar" 'A'

但我认为更好的做法是简化这个函数，只保留compileAndLoad，使其更通用。

  1. {-# LANGUAGE ScopedTypeVariables #-}
  3. module GhcApiWrap
  4.     (
  5.         msCompileAndLoad
  6.     ) where
  8. import Control.Exception.Safe
  9. import Data.Dynamic
  10. import Data.Proxy
  11. import Data.Typeable
  12. import GHC
  13. import GHC.Paths (libdir)
  14. import System.FilePath
  16. msCompileAndLoad :: forall a. Typeable a => FilePath -> FilePath -> String -> IO a
  17. msCompileAndLoad buildDir modulePath symbolName = do
  18.     dynSymbol <- runGhc (Just libdir) $ do
  19.         dflags <- getSessionDynFlags
  20.         setSessionDynFlags $ dflags { ghcLink   = LinkInMemory
  21.                                     , ghcMode   = CompManager
  22.                                     , objectDir = Just buildDir
  23.                                     , hiDir     = Just buildDir
  24.                                     }
  25.         target <- guessTarget modulePath Nothing
  26.         setTargets [target]
  27.         loadStatus <- load LoadAllTargets
  28.         case loadStatus of
  29.             Succeeded -> do
  30.                 let moduleName = dropExtension $ takeFileName modulePath
  31.                 importDecl_RdrName <- parseImportDecl $ "import " ++ moduleName
  32.                 setContext [IIDecl importDecl_RdrName]
  33.                 dynCompileExpr $ moduleName ++ "." ++ symbolName
  34.             Failed    -> throwString $ "could not load the module: " ++ modulePath
  35.     case fromDynamic dynSymbol of
  36.         Just x  -> pure x
  37.         Nothing -> throwString $ symbolName ++ " has type '" ++ show dynSymbol
  38.                  ++ "' but expected type '" ++ show symbolType ++ "'"
  39.   where
  40.     symbolType = typeRep (Proxy :: Proxy a)

然后我们可以使用它：

  1. import qualified GhcApiWrap as Ghw
  3. main :: IO ()
  4. main = do
  5.     nFromChar <- Ghw.msCompileAndLoad "../dyn/" "DynExample.hs" "nFromChar"
  6.     print $ (nFromChar :: Char -> Int) 'A'

希望这对你有帮助。

英文:

So, issue with import GHC.Paths (libdir) solved by adding a dependence to the ghc-paths package.

Next issue was with provide correct argument to the guessTarget. From the doc:

> Attempts to guess what Target a string refers to. This function implements the --make/GHCi command-line syntax for filenames.

So, need provide path to the module not just the name.

And last problem is that dynCompileExpr returns Dynamic object which should be casted to type of your function Char -&gt; Int and then calculate.

Combine all together we can get:

  1. module GhcApiWrap
  2.     (
  3.         msLoadModuleAndExecute
  4.     ) where
  6. import Control.Exception.Safe
  7. import Data.Dynamic
  8. import GHC
  9. import GHC.Paths (libdir)
  10. import System.FilePath
  12. msLoadModuleAndExecute :: FilePath -&gt; FilePath -&gt; String -&gt; Char -&gt; IO Int
  13. msLoadModuleAndExecute buildDir modulePath funcName arg = do
  14.     dynFunc &lt;- runGhc (Just libdir) $ do
  15.         dflags &lt;- getSessionDynFlags
  16.         setSessionDynFlags $ dflags { ghcLink   = LinkInMemory
  17.                                     , ghcMode   = CompManager
  18.                                     , objectDir = Just buildDir
  19.                                     , hiDir     = Just buildDir
  20.                                     }
  21.         target &lt;- guessTarget modulePath Nothing
  22.         setTargets [target]
  23.         loadStatus &lt;- load LoadAllTargets
  24.         case loadStatus of
  25.             Succeeded -&gt; do
  26.                 let moduleName = dropExtension $ takeFileName modulePath
  27.                 importDecl_RdrName &lt;- parseImportDecl $ &quot;import &quot; ++ moduleName
  28.                 setContext [IIDecl importDecl_RdrName]
  29.                 dynCompileExpr $ moduleName ++ &quot;.&quot; ++ funcName
  30.             Failed    -&gt; throwString $ &quot;could not load the module: &quot; ++ modulePath
  31.     case fromDynamic dynFunc of
  32.         Just func -&gt; pure $ func arg
  33.         Nothing   -&gt; throwString $ funcName ++ &quot; has type &#39;&quot; ++ show dynFunc ++ &quot; but expected type `Char -&gt; Int&#39;&quot;

which can be run with:

  1. import qualified GhcApiWrap as Ghw
  3. main :: IO ()
  4. main = print =&lt;&lt; Ghw.msLoadModuleAndExecute &quot;../dyn/&quot; &quot;DynExample.hs&quot; &quot;nFromChar&quot; &#39;A&#39;

But I think will be better simplify this function on just compileAndLoad that make it more generic.

  1. {-# LANGUAGE ScopedTypeVariables #-}
  3. module GhcApiWrap
  4.     (
  5.         msCompileAndLoad
  6.     ) where
  8. import Control.Exception.Safe
  9. import Data.Dynamic
  10. import Data.Proxy
  11. import Data.Typeable
  12. import GHC
  13. import GHC.Paths (libdir)
  14. import System.FilePath
  16. msCompileAndLoad :: forall a. Typeable a =&gt; FilePath -&gt; FilePath -&gt; String -&gt; IO a
  17. msCompileAndLoad buildDir modulePath symbolName = do
  18.     dynSymbol &lt;- runGhc (Just libdir) $ do
  19.         dflags &lt;- getSessionDynFlags
  20.         setSessionDynFlags $ dflags { ghcLink   = LinkInMemory
  21.                                     , ghcMode   = CompManager
  22.                                     , objectDir = Just buildDir
  23.                                     , hiDir     = Just buildDir
  24.                                     }
  25.         target &lt;- guessTarget modulePath Nothing
  26.         setTargets [target]
  27.         loadStatus &lt;- load LoadAllTargets
  28.         case loadStatus of
  29.             Succeeded -&gt; do
  30.                 let moduleName = dropExtension $ takeFileName modulePath
  31.                 importDecl_RdrName &lt;- parseImportDecl $ &quot;import &quot; ++ moduleName
  32.                 setContext [IIDecl importDecl_RdrName]
  33.                 dynCompileExpr $ moduleName ++ &quot;.&quot; ++ symbolName
  34.             Failed    -&gt; throwString $ &quot;could not load the module: &quot; ++ modulePath
  35.     case fromDynamic dynSymbol of
  36.         Just x  -&gt; pure x
  37.         Nothing -&gt; throwString $ symbolName ++ &quot; has type &#39;&quot; ++ show dynSymbol
  38.                  ++ &quot;&#39; but expected type &#39;&quot; ++ show symbolType ++ &quot;&#39;&quot;
  39.   where
  40.     symbolType = typeRep (Proxy :: Proxy a)

Then we can use it:

  1. import qualified GhcApiWrap as Ghw
  3. main :: IO ()
  4. main = do
  5.     nFromChar &lt;- Ghw.msCompileAndLoad &quot;../dyn/&quot; &quot;DynExample.hs&quot; &quot;nFromChar&quot;
  6.     print $ (nFromChar :: Char -&gt; Int) &#39;A&#39;

答案2

得分: 0

以下是您提供的内容的中文翻译：

"freestyle" 和 "K. A. Buhr" 的答案有效。

但是，我创建了一个备用版本，应该具有以下特点：

  • 不抛出异常，而是通过 Either 转发错误消息
  • 捕获所有异常以通过 Either 转发其错误消息
  • 仅在需要时修改 dflags
  • 避免使用 do 表示法
  • 避免使用 case 构造
  • 在合理情况下使用限定的导入
  • 描述所有必需的内容，包括堆栈设置细节
  • 使用模块名称来暗示文件的扩展名为“hs”
  • 无 hlint 提示

我对代码进行了测试，包括以下方面：

  • 函数
  • 模块文件不可用
    (例如，“错误：异常：找不到文件：./dyn/DynExample.hs”)
  • 编译器错误与模块文件相关
    (例如，“错误：无法加载模块“DynExample”！”)
  • 与导入符号相关的类型检查错误
    (例如，“错误：符号 nFromChar 的类型为“<<Char -> Int>>”，但期望类型为“Char -> Integer””)

GhcApiWrap

  1. {-# LANGUAGE ScopedTypeVariables #-}
  3. module GhcApiWrap
  4.     (
  5.         compileAndLoad
  6.     ) where
  8. import qualified Control.Exception.Safe as Exc
  9. import qualified Data.Dynamic as Dyn
  10. import qualified Data.Proxy as Px
  11. import qualified Data.Typeable as T
  12. import qualified GHC as Ghc
  13. import qualified GHC.Paths as Pth
  14. import Data.Functor ((<&>))
  16. compileAndLoad :: forall a. T.Typeable a => String -> String -> String -> IO (Either String a)
  17. compileAndLoad dir mdl sym = runGhcCatched >>= ethSym
  18.   where
  19.     runGhcCatched = Ghc.runGhc (Just Pth.libdir) (loadModule dir mdl sym)
  20.                     `Exc.catchAny`
  21.                     (\ex -> return (Left ("Exception: " ++ show ex)))
  22.     ethSym (Right dynSym) = return (ethSym' (Dyn.fromDynamic dynSym) (sErrFromDynSym dynSym))
  23.     ethSym (Left sErr) = return (Left sErr)
  24.     sErrFromDynSym dynSym = "Symbol " ++ sym ++ " has type \"" ++ show dynSym ++ 
  25.         "\" but expected type \"" ++ show symbolType ++ "\""
  26.     ethSym' (Just dynSym) _ = Right dynSym
  27.     ethSym' Nothing sErr = Left sErr
  28.     symbolType = T.typeRep (Px.Proxy :: Px.Proxy a)
  30. loadModule :: Ghc.GhcMonad m => String -> String -> String -> m (Either String Dyn.Dynamic)
  31. loadModule dir mdl sym = 
  32.         Ghc.getSessionDynFlags >>=
  33.         Ghc.setSessionDynFlags >> 
  34.         Ghc.guessTarget (dir ++ mdl ++ ".hs") Nothing >>= 
  35.         (\target -> Ghc.setTargets [target]) >> 
  36.         Ghc.load Ghc.LoadAllTargets >>=
  37.         returnFromLoadStatus
  38.     where
  39.         returnFromLoadStatus Ghc.Succeeded = dynSym <&> Right
  40.         returnFromLoadStatus Ghc.Failed = return (Left ("Could not load the module \"" ++ mdl ++ "\"!"))
  41.         dynSym = Ghc.parseImportDecl ("import " ++ mdl) >>= 
  42.                  (\importDecl -> Ghc.setContext [Ghc.IIDecl importDecl]) >> 
  43.                  Ghc.dynCompileExpr (mdl ++ "." ++ sym)

Usage

  1. {-# LANGUAGE LambdaCase #-}
  3. import qualified GhcApiWrap as Ghw
  5. main :: IO ()
  6. main =  Ghw.compileAndLoad "./dyn/" "DynExample" "nFromChar" >>=
  7.         (\case 
  8.             (Right nFromChar) -> putStrLn ("nFromChar 'A' := " ++ show ((nFromChar :: Char -> Integer) 'A'))
  9.             (Left sErrorMessage) -> putStrLn ("Error: " ++ sErrorMessage))

动态文件以供阅读（“DynExample.hs”）

注意：文件必须位于与目录“src”并排的目录“dyn”中，以与上面的代码（“Usage”）兼容。

  1. module DynExample
  2.     (
  3.         nFromChar
  4.     ) where
  6. import qualified Data.Char as Chr
  8. nFromChar :: Char -> Int
  9. nFromChar = Chr.ord

输出

  1. nFromChar 'A' := 65

package.yaml

  1. ...
  2. description:...
  4. dependencies:
  5. - base >= 4.7 && < 5
  6. - ghc
  7. - ghc-paths
  8. - safe-exceptions
  10. ghc-options:
  11. ...

stack.yaml

  1. ...
  2. resolver:
  3.   url: https://raw.githubusercontent.com/commercialhaskell/stackage-snapshots/master/lts/20/20.yaml
  4. ...

希望这些翻译对您有所帮助。

英文:

The answer from freestyle and K. A. Buhr works.

However, I created an alternative version, which should have the following characteristics:

  • not throwing exceptions but forwarding error messages via Either
  • catching all exceptions to forward its error messages via Either
  • not modifying the dflags if not needed
  • avoiding the do notation
  • avoiding case constructions
  • using qualified imports, where reasonably possible
  • describing all necessities including stack setup details
  • usage of the module name implying extension “hs” for the file
  • hlint free

I tested the code regarding

  • function
  • unavailability of the module file
    (e.g. "Error: Exception: can't find file: ./dyn/DynExample.hs")
  • compiler error regarding the module file
    (e.g. "Error: Could not load the module "DynExample"!")
  • error regarding type check vs. imported symbol
    (e.g. "Error: Symbol nFromChar has type "<<Char -> Int>>" but expected type "Char -> Integer"")

GhcApiWrap

  1. {-# LANGUAGE ScopedTypeVariables #-}
  2. module GhcApiWrap
  3. (
  4. compileAndLoad
  5. ) where
  6. import qualified Control.Exception.Safe as Exc
  7. import qualified Data.Dynamic as Dyn
  8. import qualified Data.Proxy as Px
  9. import qualified Data.Typeable as T
  10. import qualified GHC as Ghc
  11. import qualified GHC.Paths as Pth
  12. import Data.Functor ((&lt;&amp;&gt;))
  13. compileAndLoad :: forall a. T.Typeable a =&gt; String -&gt; String -&gt; String -&gt; IO (Either String a)
  14. compileAndLoad dir mdl sym = runGhcCatched &gt;&gt;= ethSym
  15. where
  16. runGhcCatched = Ghc.runGhc (Just Pth.libdir) (loadModule dir mdl sym)
  17. `Exc.catchAny`
  18. (\ex -&gt; return (Left (&quot;Exception: &quot; ++ show ex)))
  19. ethSym (Right dynSym) = return (ethSym&#39; (Dyn.fromDynamic dynSym) (sErrFromDynSym dynSym))
  20. ethSym (Left sErr) = return (Left sErr)
  21. sErrFromDynSym dynSym = &quot;Symbol &quot; ++ sym ++ &quot; has type \&quot;&quot; ++ show dynSym ++ 
  22. &quot;\&quot; but expected type \&quot;&quot; ++ show symbolType ++ &quot;\&quot;&quot;
  23. ethSym&#39; (Just dynSym) _ = Right dynSym
  24. ethSym&#39; Nothing sErr = Left sErr
  25. symbolType = T.typeRep (Px.Proxy :: Px.Proxy a)
  26. loadModule :: Ghc.GhcMonad m =&gt; String -&gt; String -&gt; String -&gt; m (Either String Dyn.Dynamic)
  27. loadModule dir mdl sym = 
  28. Ghc.getSessionDynFlags &gt;&gt;= 
  29. Ghc.setSessionDynFlags &gt;&gt; 
  30. Ghc.guessTarget (dir ++ mdl ++ &quot;.hs&quot;) Nothing &gt;&gt;= 
  31. (\target -&gt; Ghc.setTargets [target]) &gt;&gt; 
  32. Ghc.load Ghc.LoadAllTargets &gt;&gt;= 
  33. returnFromLoadStatus
  34. where
  35. returnFromLoadStatus Ghc.Succeeded = dynSym &lt;&amp;&gt; Right
  36. returnFromLoadStatus Ghc.Failed = return (Left (&quot;Could not load the module \&quot;&quot; ++ mdl ++ &quot;\&quot;!&quot;))
  37. dynSym = Ghc.parseImportDecl (&quot;import &quot; ++ mdl) &gt;&gt;= 
  38. (\importDecl -&gt; Ghc.setContext [Ghc.IIDecl importDecl]) &gt;&gt; 
  39. Ghc.dynCompileExpr (mdl ++ &quot;.&quot; ++ sym)

Usage

  1. {-# LANGUAGE LambdaCase #-}
  2. import qualified GhcApiWrap as Ghw
  3. main :: IO ()
  4. main =  Ghw.compileAndLoad &quot;./dyn/&quot; &quot;DynExample&quot; &quot;nFromChar&quot; &gt;&gt;= 
  5. (\case 
  6. (Right nFromChar) -&gt; putStrLn (&quot;nFromChar &#39;A&#39; := &quot; ++ show ((nFromChar :: Char -&gt; Integer) &#39;A&#39;))
  7. (Left sErrorMassage) -&gt; putStrLn (&quot;Error: &quot; ++ sErrorMassage))

Dynamic file to read ("DynExample.hs")

NOTE: The file has to be located in diretcory dyn side by side to the directory src, in order to be compatible with the code above ("Usage").

  1. module DynExample
  2. (
  3. nFromChar
  4. ) where
  5. import qualified Data.Char as Chr
  6. nFromChar :: Char -&gt; Int
  7. nFromChar = Chr.ord

Output

  1. nFromChar &#39;A&#39; := 65

package.yaml

  1. ...
  2. description:...
  3. dependencies:
  4. - base &gt;= 4.7 &amp;&amp; &lt; 5
  5. - ghc
  6. - ghc-paths
  7. - safe-exceptions
  8. ghc-options:
  9. ...

stack.yaml

  1. ...
  2. resolver:
  3. url: https://raw.githubusercontent.com/commercialhaskell/stackage-snapshots/master/lts/20/20.yaml
  4. ...

huangapple
  • 本文由 发表于 2023年8月4日 23:30:01
  • 转载请务必保留本文链接：https://go.coder-hub.com/76837326.html
  • haskell
匿名

发表评论

匿名网友

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen:

确定