我想把这样的函数重写成F#： 我的第一次尝试是： let inline private map2' (xs : seq<'T>) (ys : seq<'U>) (f : 'T -> 'U -> 'S) (g : 'T -> 'S) (h : 'U -> 'S) = let xenum = xs.GetEnumerator() let yenum = ys.GetEnumerator() seq { let r

我想做smth，比如： x `mod` 1.0 == 0 // => int 但似乎mod只适用于int。。。救命啊！ 编辑： 我试图检查给定的数字是否为三角形，所以我的想法是检查n1是否为整数 （n*（n+1））/2=s=>n1=-1+sqrt（1+ 8s））/2 总编辑： 好吧，我还是不确定你想在这里完成什么 首先，任何模1都是零，因为模函数只对整数有意义。如果你想取分数型的模，你可以先转换成整数编辑：尽管值得使用，Data.Fixed确实有一个用于非整数值的mod'函数 我也不知

是否可以在lambda函数上设置防护装置 例如： \k | k < 0 -> "negative" | k == 0 -> "zero" | otherwise -> "positive" 其他答案显示了自本答案首次编写以来引入的扩展LambdaCase和MultiWayIf如何解决这一问题。如果没有它们，最近的直接翻译有点像 \k -> case () of _ | k < 0 -> "ne

此代码给出以下错误： import Data.Monoid times :: Monoid a => Int -> a -> a times i = mconcat . replicate i main = print $ times 5 5 为什么会出现这种错误？Num在这里是如何涉及的？问题是有两个为数定义的幺半群。一个是加法，一个是乘法。这些是作为newtypes Sum和Product的实例实现的，您必须指定所需的实例，因为普通数字类型没有monoid实例 A

Laemmel和SPJ在2003年的报告中，第3页有一段代码片段 mkT :: (Typeable a, Typeable b) => (b -> b) -> a -> a mkT f = case cast f of Just g -> g Nothing -> id 然后论文解释了 也就是说，如果x的类型与f的参数类型相同，则mktfx将f应用于x 按照本文前面示例的模式，我认为必须将cast f的类型与可能（b->b）的类型进行比较，才能将

我试图找出Haskell中的iteratee I/O是什么。我查看了下面的Haskell Wiki，其中包含一些内容 我不理解该函数的第二行、第三行和最后两行的含义： enumerator :: FilePath -> Iteratee (Maybe Char) o -> IO o enumerator file it = withFile file ReadMode $ \h -> fix (\rc it -> case it of Done o ->

给定一个负数和正数序列的列表，如何使用foldr将它们划分为负数和正数序列 例如[1,2,3，-1，-2，-3,1,2,3]我将得到[1,2,3]，-1，-2，-3]，[1,2,3]] 一些疑问 我如何知道我已经比较过的前一个分区与我正在比较的分区具有相同的符号 如何将元素添加到列表中？我尝试了类似于[x]：y的东西，但是我得到的是每个元素作为一个列表并连接在一起，这不是结果 我现在拥有的是这个 foldr (\ x y -> if x >= 0 then [x]:y else

我想实现这个总数。我遇到了关于类型签名的问题 哈斯克尔的情况就是这样 crowdWrong :: (Fractional b, Integral b) => b -> b crowdWrong m = crowdWrong' m m crowdWrong' :: (Fractional b, Integral b) => b -> b -> b crowdWrong' m 1 = ((0.49) ^ (m-1)) * (0.51) * (choose m 1)

我正在通过阅读《haskell教程》一书来学习haskell，当谈到连续传球的风格时，我遇到了一个问题。这本书给出了一个cps折叠，如： cfold’ f z [] = z cfold’ f z (x:xs) = f x z (\y -> cfold’ f y xs) 并给出了试验结果： CPS> cfold (+) 0 [1,2,3,4] 10 CPS> cfold (:) [] [1,2,3] [1,2,3] 但是，当我尝试测试时，我发现存在一个问题，ghci给出： *

（我是stackoverflow的新手，我会尽我最大的努力恰当地问我的问题，如果我不这样做，请随时调查我） 所以，我是哈斯克尔的新手，我正在做一些练习来掌握窍门 我已经解决了一个练习的一半，就是用这个辅音+o'+那个辅音替换字符串中出现的每个辅音，然后返回新字符串，代码如下： hurdyGurdy c = concat [ if n `elem` "AEOUYaeouy" then [n] else [n, 'o', n] | n <- c] 您可能需要使用排序的基础： unHurdyG

假设有人想在Haskell中重新创建标准POSIX可执行文件（cat、dd、ls…）。但GHC生成的可执行文件都包括运行时代码。那么，有可能吗 要在多个可执行文件之间共享运行时代码并使它们更小、加载更快 每个系统使用一个garbadge收集器？（不确定这是否是良好的优化） 人们在Haskell中创建了典型的unix实用程序，请看 您可以将共享库与Haskell一起使用，或者更具体地说，与GHC一起使用。甚至RTS也可以是一个共享库 您不能让一个垃圾收集器实例为多个进程收集垃圾（如果您需要的话

GHCI给出错误“模式中的解析错误：b==a” 我想知道为什么会发生这种解析错误 谢谢。之所以会发生这种情况，是因为您所拥有的不是模式匹配，而这正是案例所做的。如果我没有弄错的话，在那里只允许有数据类型构造函数，而不允许有实际的函数 如果你试过类似的方法 count a [] = 0 count a (b:xs) = c + count a xs where c = case b of (b==a) -> 1 (b/=a) ->

考虑以下用例： 我有一个快速检查测试套件，包括两个测试用例prop\u testCase1和prop\u testCase2。使用我可以观察我的测试套件的代码覆盖率 但是，我希望得到关于prop_testCase1和prop_testCase2的覆盖范围的单独结果（然后进一步处理结果）。 一种解决方法是多次运行可执行文件，将测试用例明确指定为命令行参数，并在每次运行后处理生成的tix文件 然而，我宁愿把这种逻辑藏在图书馆里。实际上，我希望运行的测试用例远远不止两个。因此，为每个测试用例显式地重新

我有这样的问题： `(line 7, column 99880): unexpected "m" expecting "-->" Code: combineStylesheets 'StaticR [css_bootstrap_min_css, css_normalize_min_css] In a stmt of a 'do' block: $(combineStylesheets 'StaticR [css_bootstrap_min_css,

很抱歉问这个问题，但在我看来，它破坏了引用的透明度 在探索一个问题并将其分解（问题是获取列表的对角线元素）时，我提出了以下（正确工作）解决方案： import Data.List nums = [[1,2,3,4], [5,6,7,8], [9,10,11,12], [13,14,15,16]] southwest = transpose . zipWith (drop) [0..] southwest2 = transpose . zipWith (drop) [0..] . transp

通过阅读本章，我们可以尝试一些例子： import Pipes import qualified Pipes.Prelude as P f1 :: Show a => Int -> [a] -> IO () f1 n xs = runEffect $ (for (each xs) (lift . putStrLn . show)) >-> P.take n >-> P.stdoutLn f2 :: Sh

似乎a对函数没有任何影响。我的理解是，这个函数接受两个参数，其中第二个是列表，并返回第一个参数和第二个列表的尾部。 但是，我对这种类型感到困惑： q3 a (b:[]) = a b q3 a (b1:b2:bs) = q3 a (b2:bs) a如何与t1->t相关？ 谢谢。函数的第一行在等号后有ab。因此a必须是一个函数，因为它是一个函数应用程序。由于b是列表元素的类型，因此a是从列表元素类型到函数返回类型的函数 q3 :: (t1 -> t) -> [t1] -> t

是否有任何方法可以为lambda函数的输入变量定义类型。这是一个函数 bstar :: Language -> Int -> Language bstar l n = case l of [] -> zero l -> case n of 0 -> [[]] n -> (\pow l n -> if n == 0 then

我有两个职能： f1 :: Bool -> Int f1 x | x == True = 5 | x == False = 10 f2 :: Int -> Int f2 x = x * 2 既然f1的输出是f2的正确输入，为什么呢 f2 f1 True 导致错误 我不知道标记什么，因此标记可能不合适。函数应用程序是左关联的，因此f2 f1 True与f2 f1 True相同，而不是f2 f1 True。f2 f1 True的类型明显错误，因为f2

有两种可能在列表中插入分隔符： [x1，sep，x2，sep，…xn] [sep，x1，sep，x2，…sep，xn] 在数据列表中使用函数“穿插”： λ> intersperse 0 [1..5] [1,0,2,0,3,0,4,0,5] λ> 0 : intersperse 0 [1..5] [0,1,0,2,0,3,0,4,0,5] 但是，可以使用隐藏（未导出）函数“prependToAll”简化第二种情况： 为什么在Data.List库中，intersperse被导出，

我需要定义一个函数来移动“笔”（从左下角的（0,0）开始），根据输入绘制正确的多边形，形状的每一侧的长度为1。我需要在不导入任何已经存在的函数的情况下执行此操作。我正在使用OpenGL绘制形状。命令定义为： data Command = Fd Double | Bk Double | Lt Double | Rt Double | Go Command | Command :> Command 我做了一个三角形，它可以工作，但现在我想说的是形状有多少边，而不是定义每个形状。三角形： tr

如何为像[“a”、“b”、“c”]这样的输入生成所有可能的真/假组合的真值表 我发现很难反复思考它 例如： 输入：[“a”，“b”] 输出： 如何表示a类型变量的真值表 type TruthTable a = [(a, Bool)] truthTables :: [a] -> [TruthTable a] 无变量的真值表是什么？只有一个：不包含变量赋值的那个 truthTables [] = [[]] 给定变量v:vs的真值表，如何为变量v:vs构建所有可能的真值表？您为vs获取每个

我正在尝试编写一个函数，它获取列表的最后一个元素，并将该元素放在列表的前面。我需要这个函数运行n次 这个函数，做翻转 flipBack' :: [a] -> [a] flipBack' xs = [last xs] ++ reverse (drop 1 (reverse xs)) 因此，上面的函数类似于下一个函数的助手函数，它接受初始字符串和需要上面函数运行的次数 rotate :: String -> Int -> String rotate xs n = flipBac

我目前正在努力使用Parsec在Haskell中构建一个Prolog。虽然我对Haskell的了解充其量也不多，但Parsec的承诺和强大的类型系统足以吸引我 我首先按照类型层次结构来映射语言，从文字原语、原子、变量到抽象规则、Head、子句 infix 6 :- data Program = Program [ProExp] data ProExp = ProExp Fact | Rule data Fact = Fact Head data Rule = Rul

我正在使用递归编写一段代码来计算列表的长度，但是有很多错误。我是一个非常初学者，我不能很好地理解Haskell。 代码如下： longListe :: [a] -> a longListe [] = error "Empty liste" longListe [x]= 1 longListe n = 1 + longListe (n-1) main = print $ longListe 以及错误： No instance for (Num a) arising from the l

假设我有一个0的列表： zeroes = repeat 0 我想修改列表中的第n个成员。是否有一个内置的，或者我可以写一些函数来实现它？首先，这可能吗 注意：是的，我知道在haskell中，如果没有状态单子，就无法真正修改任何内容，因此将其视为构造一个与元素完全相同但因元素不同的新列表。单向： (take (n-1) zeroes) ++ [desired_nth_member] ++ (drop n zeroes) 单向： (take (n-1) zeroes) ++ [desired_n

我有以下简单的数字猜测程序 import System.Random turn :: Int -> Int -> Int -> IO () turn number attempt attempts = do if attempts == 0 then putStrLn "You lose" else if attempt==number then putStrLn "You got it!"

我写了这样的排列解析示例： data Entry = Entry { first_name :: String , last_name :: String , date_of_birth :: Maybe String , nationality :: Maybe String , parentage :: Maybe String } deriving (Show) nameParser :: Parser (String, String) nameParser =

我使用大量的（^）：（numa，Integral b）=>a->b->a来定义常量因子或大小。问题是GHC抱怨默认设置为Integer 现在我知道为什么会这样了。。。我知道我可以“只”写（x^（y:：Int））来消除警告。但这看起来很“丑陋”。奥托生活在警告中也不是一个很好的选择 同样的事情也适用于（^^）：：（整数b，分数a）=>a->b->a和（**）：：浮动a=>a->a对我不可用 有人能很好地解决这个（第一世界）问题吗 编辑 刚刚发现了这段代码： alignment a = 2 ^ ce

为什么这个代码不起作用 xMal 0 _ = return () xMal n text = do text xMal (n-1) text main = xMal (putStrLn t <- getLine) (n <- readLn) xMal 0\ux=return（） xmaln文本= 做 文本 xMal（n-1）文本 main=xMal（putStrLn tHaskell不是这样工作的，使用正确的语法是： xMal 0\ux=return（） xMal n

我正在学习Haskell，为了完成一项任务，我必须打印一个蛇和梯子游戏。开始时，我正在尝试打印电路板，这就是我所做的 import Data.List aRow :: Int -> String aRow n = "+" ++ take (4*n) (intercalate "" (repeat "---+")) ++ "\n|" ++ take (4*n) (intercalate "" (repeat " |")) ++ "\n" board :: Int ->

所以我想用回力棒解析一些AIS数据会很有趣，我在第一个关卡上绊倒了。编译错误令人费解。在我试图解决这个问题之前，我已经在回飞棒中解析了类似的东西 图书馆很简单。我定义了一些基本类型及其解析器/语法： import Control.Category (id, (.)) import Control.Monad (forever) import Prelude hiding (id, (

正如所讨论的那样。我无法获取工作堆栈配置。我想建立一个项目，使用反射与ghc，最好是8.0.2或更高版本。 我该怎么做，因为将其指定为额外的deps似乎也不起作用。似乎没有发布版本的reflection支持ghc 8.0.2。自0.4版本以来，develope分支有很多变化： 所以首先我尝试了这个： resolver: lts-9.5 packages: - . - location: git: https://github.com/reflex-frp/reflex comm

我想在haskeel中实现一个方法，该方法应该在传递给该方法的字符串的每个字符之后添加空格，而不是在字符串的最后一个字符之后 比如说 Main> insertSpace "This is world" "T h i s i s w o r l d" 可以通过显式递归手工编写 insertSpace :: String -> String insertSpace [] = [] insertSpace (x:[]) = x -- you need this to kee

我试图用类型文本、封闭类型族和一堆不同的东西来模拟我自己的枚举类型。我知道GHC。泛型可能是更好的方法，但现在我想知道，到底发生了什么 通过反复试验，我不得不承认，我最终得到了这段程序，它可以编译，并且一些东西在基本情况下工作，但递归不是： {-# LANGUAGE DataKinds #-} {-# LANGUAGE KindSignatures #-} {-# LANGUAGE TypeOperators #-} {-# LANGUAGE TypeFamilies #-} {-# LANGU

我觉得学习haskell的一个心理障碍是，data有时将函数定义为数据 data Person = Person { name :: String, age :: Int } 这是直观的，类似于其他语言。但是在 newtype StateT s m a = StateT { runStateT :: s -> m (a,s) } 这基本上是调用一个函数s->m（a，s）“data” 我很容易理解，在高阶函数中，“函数”实际上是作为数据传递的。但是在类型定义中，使用函数定义

合并排序中使用的merge函数可以定义为： merge a@(x:xs) b@(y:ys) | x < y = x : merge xs b | otherwise = y : merge a ys merge [] b = b merge a [] = a merge a@（x:xs）b@（y:ys）|xb（其中Ord b）作为一个比较器。我认为如果我们要求f（tail-xs）>=f-xs，我们会得到一些很酷的东西。我认为，在

我正在尝试构建一个Haskell CLI，它既可以从stdin中读取字符串，也可以从如下参数中读取： cat colors-multi-line | colorshift -d 10 colorshift -d 10 "#FFFFFF" 如何实现这一点？有几个库可以处理CLI参数解析。是我最熟悉的一个。而getContents在Prelude中阅读STDIN你就按照你刚才说的去做。您可以使用getArgs从命令行读取内容，也可以使用getLine从stdin读取内容。你没有说什么时候你希望它

我正在尝试做一些alpha-beta剪枝，当我想到如何处理这个问题时，我能理解和想到的算法 但我必须用Haskell来写这篇文章，我正在努力将我的思维方式从循环和变量等的过程转换为Haskell的函数方法 让我非常困惑的是如何写这样的东西 function alphabeta(node, α, β, player) is . . value := −∞ for each child of node do value := max(value, al

我在读： 只返回6 我对失败的行为及其在示例中的有用性感到困惑。 在查看代码时，我认为fail zero可能具有以下含义： 程序永远不会到达那个点 懒惰 还有别的。 然后我意识到，在类型内聚之后，异常就没有任何文档记录了。仍然让我困惑的是，如果没有类型强制，失败只是程序中的一个错误 Prelude> fail "zero" :: Maybe Int Nothing Prelude> fail "abc" :: [Int] [] Prelude> fail "zero" ***

我试图创建一个实现基本队列行为的队列类型类。我的代码如下： {-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE FunctionalDependencies #-} data QueueA a = QueueA { front :: [a], rear :: [a] } class Queue a b | a -> b where empty :: a null :: a -> Boo

然而，我发现关于哈斯克尔单子的推理也是非常困难的。正如您在我链接的问题的答案中所看到的，我们需要一个大图来理解do符号的3行。最后，我总是打开stackedit.io手动对do表示法进行去语法处理，并逐步编写>>=do表示法的应用程序，以便理解代码 问题大致是这样的：在大多数情况下，当我们有sa>>=f时，我们必须从S中展开a并将f应用于它。然而，f实际上是另一个或多或少以a>>=g的形式存在的东西，我们还必须将其展开，以此类推。人类的大脑不是这样工作的，我们不能轻易地在大脑中应用这些东西，然后

我正在使用Hoopl库进行一个项目，我遇到了一个障碍，它向我表明我不完全了解引擎盖下发生了什么。简而言之，Hoopl似乎认为我的图中的一些块是不可到达的，IMO不应该达到。我正在实现一个稀疏条件常量传播，所以我确实希望某些块变得不可访问，但不是所有的块！下面是一个来自HUnit测试套件的示例，我正在使用它来制作原型。这个例子使用了几个没有在这里定义的函数，但是我对这些函数进行了单独的单元测试，以确认它们是独立工作的，特别是来自Hoopl的。TohooplX按预期工作，以此类推 我期望发生的是bl

我正在尝试使用cabal安装QuickCheck库，但是即使安装成功，程序也不会运行。我使用命令： cabal install QuickCheck 安装完成。我将其导入haskell文件，如下所示： 导入测试。快速检查 但是，我得到的错误是找不到QuickCheck模块： error: Could not find module `Test.QuickCheck' Use -v (or `:set -v` in ghci) to see a list of the files

我目前正在研究一些二叉树的算法。然而，我遇到了一个我不能完全解决的问题。我总是遇到以下错误： 错误：分析输入“|”时出错 虽然我理解这与间距有关，但我认为我应该做得正确 delTree a Leaf = error "No tree here!" delTree a (Branch left w right) | a < w = delTree a left | a > w = delTree a right | a ==

我从赫顿的书《哈斯克尔编程》（第二版）中学习哈斯克尔。在第7章“高阶函数”开头，函数“两次”定义为： twice :: (a -> a) -> a -> a twice f x = f (f x) 然后给出了一些使用示例，例如： > twice reverse [1,2,3] [1,2,3] 然后作者说，“将一个（有限）列表反转两次没有效果，这一事实可以通过公式twitter reverse=id……得到。” 当我启动ghci并编写： GHCi, version 8.

如标题中所述，例如，我有一个函数，它当然会抛出一个错误： bhaskara a b c = if discriminant >= 0 then (x1,x2) else str_disc where discriminant = (b^2 - (4*a*c)) str_disc = "the discriminant is less than zero" x1 = ((-b) - sqrt (b^2 -

我有以下数据结构和功能： data BTree a = BLeaf | BNode (BTree a) a (BTree a) deriving (Show, Eq) freshNodesS :: BTree String -> State [String] (BTree String) freshNodesS BLeaf = return BLeaf freshNodesS (BNode l m r) = do l' <- freshNodesS l

我目前正在尝试打印列表列表中的整数，并且正在努力了解最有效的方法 该列表的示例如下所示： [ [ [ 2,3 ], [ 1,6 ] ] , [ [ 5,9 ], [ 2,9 ] ] , [ [ 6,2 ], [ 7,7 ] ] ] 我希望打印一个字符串，如“231659296277” 如果您有任何建议，我们将不胜感激。因为这是一个三层列表，您只需将其串联两次即可： concat。海螺$ [ [ [ 2,3 ], [ 1,6 ] ] , [ [ 5,9 ], [ 2,9 ] ] , [ [ 6,

我试图从一个列表中删除连续的基数方向对，如果它们返回到相同的位置（例如，如果我们在“南”之后找到“北”，我们会删除它们，因为它们相互抵消），作为更大函数的一部分 我曾想过为此使用内置函数，但我发现我不知道如何筛选这样的对，而不是列表中的单个项 有没有办法通过过滤器，zipWith等实现这一点 例如，我试着用zipWith做这个，但它不起作用，因为我遗漏了“已删除”项对的右侧。（例如，removePairs[N，S，E，W]会导致[S，E]而不是[]） 正常规则集如下所示： isRedundant