我正在考虑如何使用Haskell的类型系统在程序中强制模块化。例如，如果我有一个web应用程序，我很好奇是否有办法将所有数据库代码从CGI代码中分离出来，将文件系统代码从纯代码中分离出来 例如，我设想了一个DB monad，因此我可以编写如下函数： countOfUsers :: DB Int countOfUsers = select "count(*) from users" 我想它是不可能使用的副作用以外的DB单子支持。我正在描绘一个更高级别的monad，它将仅限于直接的URL处理程序，

我最初使用macports安装haskell 6.10.4，但由于其中存在一些错误，我尝试卸载它，并直接从haskell站点安装更新版本6.12.3 安装程序工作正常，但当我启动ghci时，它默认为macports版本6.10.4，显然没有卸载 我试图使用： sudo ports uninstall haskell 为了摆脱macports版本，显然没有成功。如何让macports完全擦除它放在我驱动器上的版本？如果您安装了依赖于haskell的项目，则需要先卸载这些项目，或者您可以尝试使用-

假设我有一个值列表，我想对其应用一系列操作，直到得到最终结果： [0, 1, 2] firstOperation xs = map (+1) xs secondOperation xs = filter even xs thirdOperation xs = sum xs 虽然我确信还有其他更好的方法来处理这个问题，但我目前知道的唯一一种方法是定义一个函数，该函数调用嵌套在另一个函数中的所有这些函数： runAllOperations xs = thirdOperation (secondO

我为问题10编写了以下解决方案： 我想重写相同的解决方案，但这次使用let语法 {-- using dropWhile and takeWhile / more readable --} enc' :: (Eq a) => [a] -> [(Int, a)] enc' [] = [] enc' (x:xs) = let num = length $ takeWhile (==x) (x:xs) rem = dropWhile (==x) (x:xs) in (

我有两个相同程序的版本，两个版本之间只有很小的变化。我使用#if defined（PAR）-#else--#endif，然后使用或不使用-cpp-DPAR编译这两个版本。我喜欢这种方式，因为您只需要处理一个hs文件。然而，由于我的目标是编写原始程序的并行/优化版本，我想知道使用#if-#else#-endif是否会影响性能？基本上，我想要一个如何在引擎盖下工作的解释。谢谢 #if defined(PAR) import Control.Parallel import Control.Parall

“par”和“pseq”是用于数据并行还是仅用于任务并行 例如，如果它用于分隔数据项列表。我想答案是肯定的。例如，您可以使用中的parList策略并行计算列表中的元素。如果数据项的计算成本非常低，那么您可能需要更粗粒度的并行性，如parListChunk策略

我有以下输出-我很惊讶。有什么能解释为什么“我的双打”看起来这么低吗 前奏曲GHC.浮动>浮动范围（0.5e1000:：双精度） （-10211024） 前奏曲GHC.浮点>显示（0.5e1000:：双精度） “无限” 指数1000似乎离1024的极限很远（正如我预期IEEE会包含这个：：Double） 非常感谢您的帮助。最有可能的是，floatRange正在返回二进制（基-2）指数的范围。您在此处设置的基数为1024，因此您要求基数为2的指数达到3402左右。0.5e1000并不表示“2^10

作为一个更大问题的一部分，我尝试在数组中定义一个数组，如下所示： import Data.Array.Repa type Arr = Array DIM2 Int arr = force $ fromList (Z :. 5 :. 5) [1..25] :: Arr combined :: Arr combined = arr `deepSeqArray` traverse arr (\_ -> Z :. 4 :. 4 :: DIM2) (\f (Z :. x :. y) -

如何打印将IO字符串返回到标准输出的函数的输出？我无法使用“显示”或“打印”。如果要打印函数foo:：Int->IO String（例如）的结果，可以 main = do str <- foo 12 putStrLn str do表示法是第二个的语法糖，它使用基本的（>>=）组合符，该组合符具有 (>>=) :: Monad m => m a -> (a -> m b) -> m b IO是Monad类的一个实例，因此您可以在这里使用

我只是在一段Haskell代码中遇到了以下语法- data A = A Int Int | B m :: A -> Int m a = case a of A{} -> 1 _ -> 2 A{}在这里做什么？{}是否自动匹配任意数量的参数 我觉得这是在利用Haskell将语法desugars记录到一组函数和一个常规代数数据类型这一事实。是这样吗？是，A{}匹配使用A构造函数构造的任何值，无论该类型是否已使用记录语法声明 指定 表达式F{}，其中F是数据构造函数，无论

是否有类似于MATLAB、scilab或matplotlib的Haskell绘图库？它们都有非常简单的接口，就像状态机一样工作： plot(xs, ys) show() -- opens window with plot 在窗口中显示绘图并能够将其写入磁盘将是一件好事。怎么样 例如，Graphics.Gnuplot.Simple中的plotList： plotList [] [(1, 1), (2, 2), (3, 3)] 从matplotlib的一眼可以看出，我认为Haskell生态系统没

我是哈斯克尔初学者。上次我学习了斐波那契序列，所以我可以创建斐波那契序列。现在我想知道如何编写一个函数来检查数字是否属于Fib序列 我的意思是功能： belongToFib :: Int -> Bool 我真的不需要代码。一些关于如何处理这个问题的提示就足够了。提前感谢。我将为您提供一些有关惰性评估解决方案的提示： 定义所有斐波那契数的列表 检查您的输入编号是否属于该序列 以下是您需要定义的两件事的特征： fib :: [Int] belongToFib :: Int -> Boo

AFRP的整个主题听起来非常激动人心，我正试图在其中开始我自己的项目。我发现了和，它似乎是一个很好的GLUT绑定（似乎是唯一一个同时在Windows和Linux上运行的图形库） yampaglut源代码附带了一个简单的示例，我复制它来研究它。然后我想扩展它，为关键事件添加一个简单的测试。它的全部来源是，除了第23行和按键功能外，没有什么新功能： keys = proc ev -> do rec e <- keyAction -< ev l

当我们创建一个类型类时，我们通常假设它的函数必须遵循某些属性。因此，我们有各自类型类的幺半群和单子定律。但是，如果有一些规律，比如结合性，我想指定多个类可能遵守或不遵守该规律，该怎么办？在Haskell的类型系统中有没有这样做的方法？这种针对类型类的类型类的想法在实践中是否可行 下面是一个来自代数的激励示例： class Addition x where add :: x -> x -> x class Multiplication x where mult ::

我对Haskell不是很精通，所以这可能是一个非常简单的问题 语言限制能解决什么问题？Haskell中的函数是否已经支持多态参数 Haskell中的函数是否已经支持多态参数 他们有，但只有排名第一的。这意味着，虽然您可以编写一个不使用此扩展而接受不同类型参数的函数，但您不能编写一个在同一调用中将其参数作为不同类型使用的函数 例如，如果没有此扩展名，则无法键入以下函数，因为g在f的定义中与不同的参数类型一起使用： f g = g 1 + g "lala" 请注意，将多态函数作为参数传递给另一个函

在表单中时，如何让put处理StateT monad loop :: Integer -> StateT World IO () loop passes = do (scene, b1) <- get forM_ [1..passes] $ \pass -> do let b2 = foo b1 pass -- other stuff -- put (scene, b2) -- this no longer put

使用Control.Applicative对Parsec非常有用，但您需要始终隐藏和类似对象，因为它们与Parsec自己的对象冲突： import Control.Applicative hiding ((<|>), many, optional) import Text.Parsec.Combinator import Text.Parsec 导入控件。应用程序隐藏（（），多个，可选） 导入Text.Parsec.Combinator 导入文本.Parsec 或者，正如Anta

我对Parsec的一个常见问题是，如果无效输入发生在“正确”的地方，它往往会忽略它 作为一个具体的例子，假设我们有integer:：Parser Int，我写 expression = sepBy integer (char '+') （暂时忽略空白问题。） 这正确地解析了类似“123+456+789”的内容。但是，如果我输入“123+456-789”，它会愉快地忽略非法的“-”字符和表达式的尾随部分；实际上，我想要一条错误消息，告诉我有关无效输入的信息，而不是让它默默地忽略该部分 我明白为什

我刚刚编写了我的第一个Haskell程序，但有一个错误我无法理解。我认为这是对的，因为我只是像一本书中的例子那样写的。谁能帮我一下吗 main = do putStrLn "Hello, what's your name?" name <- getLine putStrLn ("Hey" ++ name ++ ", nice to meet you!") main=do 你好，你叫什么名字 name虽然无法从您发布的代码中分辨出来，因为SO至少在某些时候会将制表符

如果STM事务失败并重试，对writechan的调用是否会重新执行，从而导致两次写入，或者STM是否仅在事务提交时才实际执行写入？i、 例如，这种解决睡眠理发师问题的方法有效吗？或者，如果enterShop中的交易第一次失败，客户可能会理发两次 import Control.Monad import Control.Concurrent import Control.Concurrent.STM import System.Random import Text.Printf runBarber

我是Haskell的新手，我想回答这个问题？我不希望人们为我做这件事，但任何指点都会有帮助，因为我真的不知道从哪里开始 根据具体情况，a->a、[（a，a）]或映射a中的任何一个都可以是字母表上替换密码的适当表示a数据结构是否与函数/定义相同？@Eddie Nope。但是，除非你问一个更好的问题，否则很难说什么更有帮助。Haskell中的数据结构是什么？因为我知道一个函数或定义由一个带：：的类型定义和一个带=。还是我也误解了？@Eddie有很多好的Haskell教程。我不会尝试在StackOve

我的问题是关于Haskell程序设计的。但是我想集中讨论一个特定的用例 我定义了一个数据类型（例如Foo），并通过模式匹配将其用于函数（例如f）。后来，我意识到类型（Foo）需要一些额外的字段来支持新功能。但是，添加字段会改变类型的使用方式；i、 e.取决于类型的现有功能可能会受到影响。在现有代码中添加新功能，无论多么没有吸引力，都是不可避免的。我想知道在Haskell语言级别有哪些最佳实践可以最大限度地减少此类修改的影响 例如，现有代码是： data Foo = Foo { vv :: [

我需要一个函数，它和 到目前为止，我得出了以下结论： {-| forward application -} x -: f = f x infixl 0 -: {-| combinations 2 "ABCD" = ["AB","AC","AD","BC","BD","CD"] -} combinations :: Ord a => Int -> [a] -> [[a]] combinations k l = (sequence . replicate k) l -: map

这是一个关于Clojure与其他语言（如Haskell）的表达能力的问题。更广泛的问题是解决问题的办法 得出的结论是，一般来说，Clojure协议（和多方法）不如Haskell TypeClass表达，因为协议在第一个参数上调度，而Haskell TypeClass可以在返回类型上调度。（现在我认为这个推理非常有趣，我对发动语言战争没有兴趣，我只是对思想的清晰感兴趣） 作为分解这个推理的一部分，我的问题是-我们能不能创建一个Clojure多方法，在返回类型（或类型提示）时进行分派。我认为我们可以

我想知道Haskell中是否有一个已定义的typeclass，它声明了连接 对于列表，有++和concat。但当然还有其他类型是可归纳的 例如： type Valuater = A -> [Int] concatValuater :: [Valuater] -> Valuater concatValuater vs = \a -> concat [v a | v <- vs] 类型赋值器=A->[Int] concatevaluer:：[evaluer]->evalue

我遇到了一些简短的一元代码，我有一个问题与示例的实际主题无关 ap :: (Monad m) => m (a -> b) -> m a -> m b ap mf mx = do f <- mf x <- mx return (f x) ap:：（单子m）=>m（a->b）->ma->mb ap mf mx=do f b）->m a->m b ap mf mx=do x一个简单的例子，它们不一样（因为它们有不同的

我有 root/Main.hs： import ADT.Stack main :: IO () main = putStrLn "Hi" root/ADT/Stack.hs module Stack (Stack, empty, isEmpty, push, top, pop) where ... 加载Main.hs时，我有一个错误 File name does not match module name: … Saw: ‘Stack’ Expected: ‘ADT

我在读给Haskell升职的书 我遇到了这种语法（如果您使用{-#语言、签名、GADT、数据类型、类型运算符#-}，这种语法是有效的）： 使用:info[]检查[]的信息，告诉我列表的数据类型是： data [] a = [] | a : [a] 这让我想到，这种风格也应该起作用，因为[]类型构造函数现在被提升为一种构造函数： data HList :: [] * -> * where HNil :: HList '[] HCons :: a -> HList as

我正试图编写一个简单的代码来生成所有括号的组合。但是我遇到了一个简单的类型错误 balancedParens :: Int -> [String] balancedParens n | n==0 = [] | otherwise = placeParens 0 1 0 n [""] where placeParens x lc rc n mlist | lc

我找到了以下类实例：（Monad m，（~）*a（））=>LaTeXC（LaTeXT ma），但不能完全理解其上下文 （~）*a（）是什么意思？我在哪里可以读到它？（~）是类型级别的相等（你可以把它写成=或=的一些变体，但意见是这个符号已经有了足够多的不同含义，引入另一个符号会让人困惑）*是类型的类型。因此，（~）*是两种（可居住）类型相等的断言。换句话说，实例也可以这样编写： instance Monad m => LaTeXC (LaTeXT m ()) 为什么不是呢？这是一个推理的

我开始学习Haskell，并一直在阅读Haskell的wiki页面，该页面报告了qsort实现： qsort :: (Ord a) => [a] -> [a] qsort [] = [] qsort (x:xs) = qsort less ++ [x] ++ qsort more where less = filter (<x) xs more = filter (>=x) xs 但我不确定这是否真的更好。我的意思是，它是

我们有这些功能 foo x1 x2 ... xN = f1 x = f2 x = ... fN x = uncurryPairsN f (x1,(x2,...)) = f x1 x2 ... xN curryPairsN f x1 x2 ... xN = f (x1, (x2, ...)) 这个函数是否有惯用的无点版本 bar x1 x2 ... xn = foo (f1 x1) (f2 x2) ... (fN xN) 编辑 如果不是，我们能把这个函数推广到N个参数吗 applyF

问题说明了一切。。。。我正在使用Data.conductor.Network，有时服务器没有启动。默认超时需要几分钟，我的程序需要在几秒钟内知道 {-# LANGUAGE OverloadedStrings #-} import Data.Conduit.Network main = do --use any IP address that isn't up.... I use 1.2.3.4 for testing runTCPClient (clientSettings 80 "1

作为trifecta的实验，我编写了以下简单函数： filterParser :: (a -> Bool) -> Parser a -> Parser a filterParser cond p = do a <- p if cond a then return a else unexpected "condition failed!" 但与“许多”相比，它不起作用-比较： > parseString (many $ filterPa

在项目内外运行stack install hsdev时出现此错误： λ stack install hsdev Run from outside a project, using implicit global project config Using resolver: lts-5.11 from implicit global project's config file: C:\Users\atc\AppData\Roaming\stack\global-project\stack.yaml

我需要修改这个文件，通过使用两个参数“A，B”，使“square/2”Prolog规则在haskell中工作 参数是数字列表。这两个列表应该有相同数量的元素。只有当所有元素B都是A中元素的平方且顺序相同时才是真的。下面的代码是Prolog规则的基本情况 正方形（[]，[]）。它可以简单地写出来 isSquare [] [] = True isSquare (x:xs) (y:ys) = x*x==y && isSquare xs ys 也许您也希望添加相等的长度 也可以写 an

我目前正在使用bytestring和attoparsec在游戏netcode中分别进行序列化和反序列化。我最初被吸引在groove上使用这些库，因为bytestring提供了对构建器的非常精细的控制，包括有用的和有用的。我认为这将是一个很好的选择，因为这将确保我能够更好地处理项目中稍后可能遇到的任何延迟/GC问题 虽然bytestring为数据包字段（主要是data.Word和data.Int中的类型，如Word16，Word16和Int8）中遇到的常见数据类型提供了许多组合符，当我在attop

我想预先计算一些值，然后在需要进一步查找时使用这些值。我得出了以下结论： import qualified Data.Vector.Unboxed as V lcgen s = lc where lc 0 b = lengths V.! b lc a b = lengths V.! b - lengths V.! (a - 1) - 1 lengths = V.fromList $ scanl1 ((+) . (1 +)) $ map length $ wo

假设我有一个所有素数的列表，定义为 primes :: (Enum α, Integral α) => [α] primes = sieve [2..] where sieve :: (Integral α) => [α] -> [α] sieve [] = undefined sieve (x:xs) = x : (sieve $ filter ((/= 0) . (flip mod x)) xs) 我想通过多个不同的功能，如：

使用ghc v8.0.1，使用-O2标志编译 我对RecursiveDo（mdo）有问题。有两个稍微不同的函数应该产生相同的输出，但它们没有 以下函数产生正确的输出： 以下函数产生不正确的输出： 从0007到000A的行是从0003到0006的行的副本，并且（在这种特殊情况下）最终结果是0007处的无限循环 所讨论的代码在Haskell中实现了一个EDSL（Ting Pen的汇编器）。该程序的输出是一个Ting Pen的机器代码 我使用MonadFix能够捕获汇编语言中的前向标签，当我使用一些代

在拓扑排序算法中，我们执行DFS并在遇到节点时将其推送到链表上。我能想到的功能上实现这一点的唯一方法是将列表作为参数传递到调用中，这很难看而且效率很低（即，它显示在大O中，因为复制列表是O（n）.在Haskell中，人们将如何惯用这种方法？讨论这个确切的问题，作为如何以函数式方式进行图形算法的第一个示例： [编者按：本文前面介绍了符号c&vg，作为一种“图形上的模式匹配”：c&v g匹配包含顶点的图形v，将c绑定到给定顶点内外边的上下文，并将g绑定到删除该节点及其所有边的图形。在Haskell库

我希望看到的是： "\"val1\",\"val2\", 相反，这会使我的会话崩溃 Segmentation fault (core dumped) 问题: 我对懒惰、bytestrings、mmap库或Haskell有什么错 我如何才能正确地获得这一行，并与内存效率？（答案可能是使用外部指针而不是懒惰的ByTestRing？） 对于其他读者，如果您想了解最后一行，您可能会找到一种非常快速和合适的方法，如以下答案所述： 在这个线程中，我特别寻找使用mmap的解决方案。我更喜欢使用与bytes

我试图将约束应用于一组值，使用间隔作为其可能值的范围。对于如何在Haskell中应用这些约束，我很难制定一种方法 假设我有一个形式为b=10的约束和一个形式为a=f（b，c）的约束，显然第一个约束将改变第二个约束的应用方式，但是我不确定如何在函数式语言中实现这一点。在命令式程序中，我们将改变b的间隔，并在第二个约束中使用它的新值 如果您能提供任何帮助，我们将不胜感激，本这个问题可能近乎“过于笼统”，因此这里有一个可能“过于笼统”的答案，尽管我尝试了一些细节（包括一个工作示例） 在这样的问题中，典

我有一个第一个typeclass，它接受……ofleaf的列表列表： {-# LANGUAGE MultiParamTypeClasses, FlexibleInstances, UndecidableInstances #-} class ListTree leaf t where lmap :: (leaf -> leaf) -> t -> t instance ListTree leaf leaf where lmap f v = f v instance ListT

我想从给定的元组列表创建一个矩阵。 元组有（行、列、值），我想创建矩阵[row][column]=value： buildMatrix :: Int-> [(Int, Int, Int)] -> [[Int]] 例如，假设： n = 3 (size of matrix) list = [(1,2,1), (1,3,-1), (2,3,1)], 我想去 matrix = [[0,1,-1], [0,0,1], [0,0,0]] 到目前为止，我尝试的是： buildMatrix n

非常令人惊讶的是，我试图通过显式地添加为特定模块逐个导入的元素来修复编译警告缺少导出列表，但不知何故，这个模块隐式导出了一些神奇的东西，我找不到 是否可以检索使用ghc隐式导出的内容 这是我的问题的一个例子，Yesod正在生成一些带有TH和Quasiqueotes的代码： {-# LANGUAGE EmptyDataDecls #-} {-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE GADTs

我一直在按照Pierce的类型和编程语言在Rust中实现System F-omega，我正在寻找使用iso recursivefold/unfold操作符向我的实现中添加递归类型的指导。我已经添加了sum、product、record、existential和universal类型 在SystemF（w/o类型运算符）中，我发现这相对简单，我只是让访问者在解析后通过AST，在案例分析或类型构造期间执行折叠/展开同构 对于System F omega，由于在类型级别存在lambda抽象，因此情况稍

我试图理解Haskell中的存在主义类型，并偶然发现了一个PDF 请纠正我到目前为止的以下理解 存在类型似乎对它们包含的类型不感兴趣，但匹配它们的模式表示存在某种类型，我们不知道它是什么类型，除非我们使用Typeable或Data 当我们想要隐藏类型（例如：异构列表）或者在编译时不知道类型是什么时，我们使用它们 GADT通过为所有提供隐式，为使用存在类型的代码提供了清晰、更好的语法 我的怀疑 在上面PDF的第20页中，下面的代码提到函数不可能要求特定的缓冲区。为什么会这样？当我起草一个函数

我试图用Haskell自学函数式编程 我很难理解咖喱和羊肉 这是一个函数，用于生成列表的prfixes列表（输出列表列表） 我正在尝试将其重写为一个常规函数，而不使用lambda来帮助我理解lambda是如何工作的。我该怎么做？我被卡住了。我需要一个助手函数吗？谢谢。是的，您需要一个助手函数where子句是放置此类助手的好地方其中子句附加到定义中，因此我需要命名您的函数（我已经命名了它）。首先，逐字逐句地将表达式移出 inits :: [a] -> [[a]] inits = foldr

我正在阅读Scott Wlaschin的优秀文章，并运行一些Haskell代码来理解这些概念（Functor，Applicative，…）。我偶然发现了一种我不理解的行为 为什么计算pure add1什么也不打印？计算表达式的值是多少？为什么pure add1“abc”将函数add1返回给我 我知道，pure将一个值提升到提升的世界（本文中称之为）。由于我没有在某个地方提供具体的提升值或足够的类型信息，因此类型约束是通用的，并且保持Applicative f。因此，我理解纯add1的类型。但是这