Haskell printf参数作为数组

我想用数组调用 Text.Printf 函数 printf 但我找不到方法。
这是两个不起作用的版本(实际上是相同的想法)。

import Text.Printf

printfa :: (PrintfArg a) => String -> [a] -> String
printfa format args = step (printf format) args
  where
    step :: (PrintfType r, PrintfArg a) => r -> [a] -> r
    step res (x:[]) = res x
    step res (x:xs) = step (res x) xs

printfa' :: (PrintfArg a) => String -> [a] -> String
printfa' format args = foldr (\arg p -> p arg) (printf format) args

main = putStrLn $ printfa "%s %s" ["Hello", "World"]

GHC 错误是:

printfa.hs:8:23:
    Couldn't match type `r' with `a1 -> r'
      `r' is a rigid type variable bound by
          the type signature for
            step :: (PrintfType r, PrintfArg a1) => r -> [a1] -> r
          at printfa.hs:8:5
    The function `res' is applied to one argument,
    but its type `r' has none
    In the expression: res x
    In an equation for `step': step res (x : []) = res x

printfa.hs:12:41:
    The function `p' is applied to one argument,
    but its type `String' has none
    In the expression: p arg
    In the first argument of `foldr', namely `(\ arg p -> p arg)'
    In the expression: foldr (\ arg p -> p arg) (printf format) args

(为什么:我正在编写 DSL 并希望提供 printf 功能。)

最佳答案

首先，认识到PrintfArg a => [a]不是一个异构列表。也就是说，即使Int和String都是PrintfArg的实例，[ 1 :: Int, "foo" ]也不是有效的构造。

因此，如果您确实定义了一个函数:: PrintfArg a => String -> [a] -> String，那么所有的args都将被约束为同一类型。

为了解决这个问题，您可以使用存在量化。

{-# LANGUAGE ExistentialQuantification #-}
import Text.Printf

data PrintfArgT = forall a. PrintfArg a => P a

printfa :: PrintfType t => String -> [ PrintfArgT ] -> t
printfa format = printfa' format . reverse
  where printfa' :: PrintfType t => String -> [ PrintfArgT ] -> t
        printfa' format [] = printf format
        printfa' format (P a:as) = printfa' format as a

main = do
  printfa "hello world\n" []
  printfa "%s %s\n" [ P "two", P "strings"]
  printfa "%d %d %d\n" (map P $ [1 :: Int, 2, 3])
  printfa "%d %s\n" [ P (1 :: Int), P "is the loneliest number" ]

您的第一个解决方案不起作用的原因是因为您将res传递给step作为参数。

当您拥有foo :: Constraint a => a -> t时，请确保foo将对Constraint的所有实例都有效。尽管存在一个可以接受参数的PrintfType实例，但并非所有实例都可以。因此，您的编译器错误。

相反，当您拥有foo :: Constraint a => t -> a时，您可以确保foo将返回Constraint的任何所需实例。同样，调用者可以选择哪个实例。这就是为什么我的代码有效的原因-当printfa'递归时，它需要递归调用才能从(PrintfArg a, PrintfType t) => a -> t实例返回一个值。

对于您的第二次尝试，编译器会提示，因为foldr要求迭代之间的累加值具有相同的类型。 GHC注意到累积值必须是函数类型(PrintfArg a, PrintfType t) => a -> t，因为您将其应用于迭代函数中。但是，您返回的应用值可以确定为t类型。这意味着t等于a -> t，GHC不喜欢它，因为它不允许无限类型。因此，它提示。

如果要使用折叠，则可以使用Rank2Types或RankNTypes屏蔽累加器类型，以使两次迭代之间的类型保持不变。

{-# LANGUAGE ExistentialQuantification #-}
{-# LANGUAGE RankNTypes #-}
import Text.Printf

data PrintfArgT = forall a. PrintfArg a => P a
data PrintfTypeT = T { unT :: forall r. PrintfType r => r }

printfa :: PrintfType t => String -> [ PrintfArgT ] -> t
printfa format = unT . foldl (\(T r) (P a) -> T $ r a ) (T $ printf format)

关于Haskell printf参数作为数组，我们在Stack Overflow上找到一个类似的问题：https://stackoverflow.com/questions/18243480/