我非常感兴趣的是从代码编写的命令行shell脚本源代码生成，该代码以更强健，性能更好且与平台无关的编译语言（例如OCaml）编写。基本上，您可以使用编译语言编程来执行与您想要的操作系统的任何交互（我建议：更复杂的交互或以平台无关的方式不容易做到的交互），最后您将编译它到本机二进制可执行文件（最好），它会生成一个shell脚本，在shell中生成你在编译语言中编写的内容。 [ ADDED ]：对于'效果'，我的意思是设置环境变量和shell选项，执行某些非标准命令（标准脚本'glue'将由编译的可执行文件处理，并且将是保持在生成的shell脚本之外）等等。
到目前为止，我还没有找到任何此类解决方案。与今天的其他可能性相比，实现它似乎相对容易*，比如将OCaml编译为JavaScript。
我做的不意味着
实际应用
你们中的一些人可能怀疑我所描述的实际用途。这样做的一个实际应用是根据各种条件定义shell配置文件（例如，配置文件来源的系统平台/操作系统，安全策略，具体shell，登录/非登录类型shell，交互/非交互式shell）。作为shell脚本的（精心设计的）通用shell配置文件的优势在于性能的提高（可能生成压缩/优化的源代码而不是人工编写的脚本解释的本机机器代码），健壮性（类型检查，异常处理） ，编译功能的时间验证，生成的二进制可执行文件的加密签名），功能（更少或不依赖于用户域CLI工具，不限制使用所有可能平台的CLI工具所涵盖的最低功能）和跨平台功能（在像单一UNIX规范这样的实践标准只是意味着很多，而且很多shell配置文件概念也会转移到非Windows平台，如PowerShell，以及它的PowerShell。
实施细节，附带问题
感谢您的进一步想法，特别是对于具体的建议！
答案 0 :(得分：13)
没有Haskell库，但您可以使用抽象语法树实现它。我将构建一个简单的玩具示例，该示例构建一个与语言无关的抽象语法树，然后应用将树转换为等效Bash脚本的后端。
我将使用两个技巧来建模Haskell中的语法树：
GADT技巧相当简单，我使用了几种语言扩展来增强语法：
{-# LANGUAGE GADTs
, FlexibleInstances
, RebindableSyntax
, OverloadedStrings #-}
import Data.String
import Prelude hiding ((++))
type UniqueID = Integer
newtype VStr = VStr UniqueID
newtype VInt = VInt UniqueID
data Expr a where
StrL :: String -> Expr String -- String literal
IntL :: Integer -> Expr Integer -- Integer literal
StrV :: VStr -> Expr String -- String variable
IntV :: VInt -> Expr Integer -- Integer variable
Plus :: Expr Integer -> Expr Integer -> Expr Integer
Concat :: Expr String -> Expr String -> Expr String
Shown :: Expr Integer -> Expr String
instance Num (Expr Integer) where
fromInteger = IntL
(+) = Plus
(*) = undefined
abs = undefined
signum = undefined
instance IsString (Expr String) where
fromString = StrL
(++) :: Expr String -> Expr String -> Expr String
(++) = Concat
这让我们可以在DSL中构建类型化的Bash表达式。我只实现了一些原始操作，但你可以很容易想象如何将它扩展到其他人。
如果我们不使用任何语言扩展，我们可能会编写如下表达式：
Concat (StrL "Test") (Shown (Plus (IntL 4) (IntL 5))) :: Expr String
这没关系，但不是很性感。上面的代码使用RebindableSyntax覆盖数字文字，以便您可以仅使用(IntL n)替换n：
Concat (StrL "Test") (Shown (Plus 4 5)) :: Expr String
同样，我Expr Integer实施Num，以便您可以使用+添加数字文字：
Concat (StrL "Test") (Shown (4 + 5)) :: Expr String
同样，我使用OverloadedStrings，以便您可以用(StrL str)替换所有str次出现：
Concat "Test" (Shown (4 + 5)) :: Expr String
我还覆盖了Prelude (++)运算符，以便我们可以将表达式连接起来，就像它们是Haskell字符串一样：
"Test" ++ Shown (4 + 5) :: Expr String
除了从整数到字符串的Shown转换之外，它看起来就像本机Haskell代码。整齐！
现在我们需要一种方法来创建一个用户友好的DSL，最好用Monad语法糖。这是免费的monad进来的地方。
免费monad采用函数表示语法树中的单个步骤，并从中创建语法树。作为奖励，它始终是任何仿函数的monad，因此您可以使用do表示法汇编这些语法树。
为了演示它，我将在前面的代码段中添加更多代码：
-- This is in addition to the previous code
{-# LANGUAGE DeriveFunctor #-}
import Control.Monad.Free
data ScriptF next
= NewInt (Expr Integer) (VInt -> next)
| NewStr (Expr String ) (VStr -> next)
| SetStr VStr (Expr String ) next
| SetInt VInt (Expr Integer) next
| Echo (Expr String) next
| Exit (Expr Integer)
deriving (Functor)
type Script = Free ScriptF
newInt :: Expr Integer -> Script VInt
newInt n = liftF $ NewInt n id
newStr :: Expr String -> Script VStr
newStr str = liftF $ NewStr str id
setStr :: VStr -> Expr String -> Script ()
setStr v expr = liftF $ SetStr v expr ()
setInt :: VInt -> Expr Integer -> Script ()
setInt v expr = liftF $ SetInt v expr ()
echo :: Expr String -> Script ()
echo expr = liftF $ Echo expr ()
exit :: Expr Integer -> Script r
exit expr = liftF $ Exit expr
ScriptF仿函数代表了DSL中的一个步骤。 Free基本上创建了一个ScriptF步骤列表，并定义了一个monad，我们可以在其中汇编这些步骤的列表。您可以将liftF函数视为一步并创建一个包含一个操作的列表。
然后我们可以使用do表示法来汇编这些步骤，其中do表示法连接这些操作列表：
script :: Script r
script = do
hello <- newStr "Hello, "
world <- newStr "World!"
setStr hello (StrV hello ++ StrV world)
echo ("hello: " ++ StrV hello)
echo ("world: " ++ StrV world)
x <- newInt 4
y <- newInt 5
exit (IntV x + IntV y)
这显示了我们如何组装我们刚刚定义的原始步骤。这具有monad的所有优良属性，包括对monadic组合器的支持，如forM_：
import Control.Monad
script2 :: Script ()
script2 = forM_ [1..5] $ \i -> do
x <- newInt (IntL i)
setInt x (IntV x + 5)
echo (Shown (IntV x))
注意我们的Script monad如何强制执行类型安全，即使我们的目标语言可能是无类型的。您不能意外地使用期望String的{{1}}字面值，反之亦然。您必须使用Integer等类型安全转换在它们之间进行显式转换。
另请注意，Shown monad会在exit语句后吞下所有命令。他们甚至在到达口译员之前就被忽略了。当然，您可以通过重写Script构造函数来接受后续Exit步骤来更改此行为。
这些抽象语法树是纯粹的，这意味着我们可以纯粹地检查和解释它们。我们可以定义几个后端，例如将我们的next monad转换为等效的Bash脚本的Bash后端：
Script我定义了两个解释器：一个用于表达式语法树，另一个用于monadic DSL语法树。这两个解释器将任何与语言无关的程序编译成等效的Bash程序，表示为String。当然，表达的选择完全取决于你。
每次bashExpr :: Expr a -> String
bashExpr expr = case expr of
StrL str -> str
IntL int -> show int
StrV (VStr nID) -> "${S" <> show nID <> "}"
IntV (VInt nID) -> "${I" <> show nID <> "}"
Plus expr1 expr2 ->
concat ["$((", bashExpr expr1, "+", bashExpr expr2, "))"]
Concat expr1 expr2 -> bashExpr expr1 <> bashExpr expr2
Shown expr' -> bashExpr expr'
bashBackend :: Script r -> String
bashBackend script = go 0 0 script where
go nStrs nInts script =
case script of
Free f -> case f of
NewInt e k ->
"I" <> show nInts <> "=" <> bashExpr e <> "\n" <>
go nStrs (nInts + 1) (k (VInt nInts))
NewStr e k ->
"S" <> show nStrs <> "=" <> bashExpr e <> "\n" <>
go (nStrs + 1) nInts (k (VStr nStrs))
SetStr (VStr nID) e script' ->
"S" <> show nID <> "=" <> bashExpr e <> "\n" <>
go nStrs nInts script'
SetInt (VInt nID) e script' ->
"I" <> show nID <> "=" <> bashExpr e <> "\n" <>
go nStrs nInts script'
Echo e script' ->
"echo " <> bashExpr e <> "\n" <>
go nStrs nInts script'
Exit e ->
"exit " <> bashExpr e <> "\n"
Pure _ -> ""
monad请求新变量时，此解释器会自动创建新的唯一变量。
让我们试试这个解释器，看看它是否有效：
Script它生成一个bash脚本，执行等效的语言独立程序。同样，它也可以很好地翻译>>> putStr $ bashBackend script
S0=Hello,
S1=World!
S0=${S0}${S1}
echo hello: ${S0}
echo world: ${S1}
I0=4
I1=5
exit $((${I0}+${I1}))
：
script2所以这显然不全面，但希望能为您提供一些关于如何在Haskell中实现此实现的想法。如果你想了解更多关于免费monad的使用，我建议你阅读：
我还附上了完整的代码：
>>> putStr $ bashBackend script2
I0=1
I0=$((${I0}+5))
echo ${I0}
I1=2
I1=$((${I1}+5))
echo ${I1}
I2=3
I2=$((${I2}+5))
echo ${I2}
I3=4
I3=$((${I3}+5))
echo ${I3}
I4=5
I4=$((${I4}+5))
echo ${I4}