小编ham*_*mar的帖子

这是我的代码:

func :: Integer -> String
func i = "LoadC R" ++ i ++ "\n"

但是我得到了错误:

无法将预期类型`[Char]'与实际类型`Integer'匹配

我如何转换i为char？

如果将函数应用于所有元素,您会将一个函数命名为列表和函数,并返回True,会得到相同的结果吗？

def identical_results(l, func):
    if len(l) <= 1: return True
    result = func(l[0])
    for el in l[1:]:
        if func(el) != result:
            return False
    return True

这个东西有一个很好的普遍接受的名字吗？如果你能以一种不那么笨重的方式实施,就可以获得奖励.

我有点困惑如何重写严格评估列表理解以使用seq而不是bang模式:

zipWith' f l1 l2 = [ f e1 e2 | (!e1, !e2) <- zip l1 l2 ]

任何的想法 ？

我试过了

zipWith' f l1 l2 = [ e1 `seq` e2 `seq` f e1 e2 | (e1, e2) <- zip l1 l2 ]

但不幸的是,这并未强制对WHNF进行评估.

我正在寻找类似于 Python 中的 dict/list/set 推导式的东西。在Python中你可以这样做：

[x+2 for x in list if x > 10]

并在 F# 中

[for x in list do if x > 10 yield x+2]

但在Python中，你也可以这样做：

{x+2 for x in list if x > 10}

生成集合，以及

{k: (v+10)/2 for k, v in list.items() if k > 5}

生成字典。F# 中是否有任何等效的语法（无论是在功能方面还是在整体整洁方面）？

我已经制作了这种数据类型,其中有很多重复.

data JobState = UnsanitizedData Handle
              | SanitizedData Handle
              | VerifiedData Handle
              | JobFail Handle

我不希望任何这些JobStates在没有Handle的情况下使用.但重复让我怀疑我没有正确表达这一点.有没有更好的办法？

该函数需要取一个整数元素的有序列表，并返回原始列表中相邻元素的所有组合。例如[1,2,3]会返回[[1,2,3],[1],[1,2],[2],[2,3],[3]]。

请注意，[1,3]不应包括在内，因为1和3在原始列表中不相邻。

说我有一个字符串 phone = "1-800-test"

我需要将字母转换为数字.

做这样的事情是行不通的(注意我当然是循环它):

phone = phone.replace(phone.charAt(9), (char) getNumber(phone.charAt(9)));

请注意,这getNumber()是一个带字母并返回数字的方法:

int getNumber(char uppercaseLetter)

无论如何,我得到一些奇怪的输出,字母被一个奇怪的方格所取代.

我该如何用数字代替字母？

我是Haskell的新手,我一直试图在列表中映射每对的第一项.

显然这有效:

map :: (a -> b) -> [a] -> [b]
map f xs = [f x | x <- xs]

但是我该如何让它发挥作用呢

map :: (a -> b) -> [(a, Int)] -> [b]

我只是想让它暂时忽略Int值并将f应用到第一个例子中.我现在已经尝试了很多年,所以感谢任何帮助.

如何我不能在Haskell中创建一个16元组,这个错误意味着什么？

GHCi, version 7.6.2: http://www.haskell.org/ghc/  :? for help
Loading package ghc-prim ... linking ... done.
Loading package integer-gmp ... linking ... done.
Loading package base ... linking ... done.
Prelude> (1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16)

<interactive>:2:1:
    No instance for (Show
                       (t0,
                        t1,
                        t2,
                        t3,
                        t4,
                        t5,
                        t6,
                        t7,
                        t8,
                        t9,
                        t10,
                        t11,
                        t12,
                        t13,
                        t14,
                        t15))
      arising from a use of `print'
    Possible fix:
      add an instance declaration for
      (Show
         (t0,
          t1,
          t2,
          t3,
          t4,
          t5,
          t6,
          t7,
          t8,
          t9,
          t10,
          t11,
          t12,
          t13, …

我怀疑为什么Haskell无法处理以下行

Prelude> take 1000000000000 $ repeat ' '

该行代码将返回:

""

这显然不是1,000,000,000,000个空间.

如果我尝试少于零,它会打印很长时间.

最困扰我的是,如果我只是写作

Prelude> repeat ' '

它会工作,即使是一个很大多个零的.

那么,为什么Haskell不能像repeat单独使用那样打印很长时间？