小编dfe*_*uer的帖子

我有一些自然数c.我想找到所有对自然数a and b,其中a < b,如a * b = c.

我有一个解决方案:

solve c = do solveHelper [1..c] c where
                   solveHelper xs c = do
                       x <- xs
                       (division, modulo ) <- return (c `divMod` x)
                       True <- return (modulo  == 0)
                       True <- return (x <= division)
                       return (x, division)

例:

*Main> solve 10
[(1,10),(2,5)]

有没有办法加速我的代码,或者我应该使用更好的算法？

我正在学习Haskell中的异常如何工作.
当试图在Prelude中复制这个简单的例子时,我得到:

GHCi, version 7.10.2: http://www.haskell.org/ghc/  :? for help
Prelude> :m Control.Exception
Prelude Control.Exception> let x = 5 `div` 0
Prelude Control.Exception> let y = 5 `div` 1
Prelude Control.Exception> print x
*** Exception: divide by zero
Prelude Control.Exception> print y
5
Prelude Control.Exception> try (print x)

<interactive>:16:1:
    No instance for (Show (IO (Either e0 ())))
      arising from a use of `print'
    In a stmt of an interactive GHCi command: print it
Prelude Control.Exception>

为什么我得到任何情况下错误的try(print …

这可能有什么问题？我已经尝试了多种解决方案,但最终都会出现'模块'上的错误以及主要后面的=符号.有没有搞错？!？!？!

printTabuleiro :: [[Char]] -> IO()
printTabuleiro [] = []
printTabuleiro (l :lt) = putStr l : printTabuleiro lt

module Main where

main = let 
          a = ["#####\n","###o##\n"] 
       in do printTabuleiro a

现在我得到了这个编译错误,我不明白这里的类型匹配问题.顺便说一句,我是相当新的,不习惯功能,请不要把我加入火星.

[1 of 1] Compiling Main             ( visualisacao.hs, interpreted )

visualisacao.hs:14:27:
    Couldn't match expected type ‘IO ()’ with actual type ‘[IO ()]’
    In the expression: putStr l : printTabuleiro lt
    In an equation for ‘printTabuleiro’:
        printTabuleiro (l : lt) = putStr l : printTabuleiro lt

visualisacao.hs:14:38:
    Couldn't match …

Haskell的教程说,要谨慎,当我们使用"你好" +"世界",新的列表建设具有访问所有单个元素(这里的'你好’的每个字符),因此,如果对"左侧的列表++"很长,然后使用"++"会降低性能.

我认为我没有正确理解,Haskell的开发人员是否从未调整列表操作的性能？为什么这个操作仍然很慢,在任何lambda函数或currying中都有某种语法一致性？

任何提示？谢谢.

例如

partitions [1,2,3] =
  [([],[1,2,3])
  ,([1],[2,3])
  ,([1,2],[3])
  ,([1,2,3],[])]

partitions :: [a] -> [([a], [a])]
partitions (x:xs) = ([], x:xs):[(x:ys, rs) | (ys, rs) <- partitions xs]

我想知道它是懒惰的解决方案.例如partitions [1..]是无限的.另外, take 5 $ partitions [1..]也是无限的.鉴于此函数的结果是无限的,我认为这很明显.但是,如果我正确地理解懒惰,我不确定它是否是懒惰的.

reverse'::[a] -> [a]
reverse' xs=foldl (\acc x -> x:acc) [] xs
example?
reverse' [1,2,3,4,5]
output:[5,4,3,2,1]

如果我改变acc了[]

reverse' xs=foldl (\acc x -> x:[]) [] xs

它输出

[5]

为什么？

在多态性不足的情况下

作者说: def foo[A](fst: List[A], snd: List[A]): List[A]

我们实现该功能的方式较少.特别是,我们不能仅仅对列表中的某些元素进行硬编码,因为我们无法制作任意类型的值.

我不明白这一点,因为在[Char]版本中我们也没有能力制造任意类型的值,我们不得不使用类型,[Char]所以为什么实现这个的方法更少？

foldMap可以通过遍历实现:

foldMap f = getConst . traverse (Const . f)

所以,我的问题是如何通过foldMap实现遍历:

traverse f = ...

要么

it Can't be accomplished ?

现在我有树数据类型:

data TernaryTree a = EmptyTree
                   | Node a (TernaryTree a) (TernaryTree a) (TernaryTree a)
                   deriving (Show)

我正在尝试创建一个可以在三元树中循环一个值的函数.树没有排序.

treeLook :: (Ord a)=> a -> TernaryTree a -> Bool
treeLook x EmptyTree = False
treeLook x (Node a left mid right) =
    if x /= a
        then do
        treeLook x left 
        treeLook x mid
        treeLook x right
        else 
        True

我现在有这个,但我无法编译它.它说:

Couldn't match expected type "m0 b0" with actual type "bool" on the line:
    treeLook x right

在许多语言中，都有一个函数使用指定的分隔符将字符串分成多个部分。通常称为split。您可以在Python，C＃，Java，JavaScript中找到它。但是Haskell虽然相当成熟，但在标准库中仍然缺少这种功能。我知道有一个库叫做split提供此功能。但这与在标准库中具有此功能不同。

因此，尽管此功能非常方便实用，以至于许多其他语言将其添加到标准库中，但这实际上是为什么Haskell没有它的原因。没有它背后的论据是什么？

UPD：问题在于base软件包，即Prelude。换句话说，为什么有words和lines没有split？