天道酬勤,学无止境

Haskell UI do clause, how to print?

This is a follow up question to this. I'm using a graphic library in Haskell called Threepenny-GUI. In this library the main function returns a UI monad object. I'm trying to execute a simple print command with no success. What is a right work around to enable printing for debugging purposes.

Code:

main :: IO ()
main = startGUI defaultConfig setup

setup :: Window -> UI ()
setup w = do

print "debug message 1 "

Error:

Couldn't match type ‘IO’ with ‘UI’
Expected type: UI ()
  Actual type: IO ()
In a stmt of a 'do' block: print "labels and values "

评论

Based on the types, this is a good application of liftIO. liftIO has a type MonadIO m => IO a -> m a so it can be used like this:

liftIO (print "debug message 1")

The type of that expression can be UI () since UI is an instance of MonadIO and print "debug message 1" has the type IO ().

受限制的 HTML

  • 允许的HTML标签:<a href hreflang> <em> <strong> <cite> <blockquote cite> <code> <ul type> <ol start type> <li> <dl> <dt> <dd> <h2 id> <h3 id> <h4 id> <h5 id> <h6 id>
  • 自动断行和分段。
  • 网页和电子邮件地址自动转换为链接。

相关推荐
  • Scala 相当于 Haskell 的 where 子句?(Scala equivalent to Haskell's where-clauses?)
    问题 是否可以使用类似于 Scala 中的 where-clauses 的东西? 也许有一些我没有想到的技巧? 编辑: 感谢您的所有回答,非常感谢。 总结一下:local vars, vals 和 defs 可以用来实现几乎相同的事情。 对于惰性求值,可以使用惰性 val(带有隐式缓存)或函数定义。 确保功能纯度留给程序员。 现在只剩下一个问题:有没有办法将值或函数定义放在它们被使用的表达式之后? 有时这似乎更清楚。 这对于类或对象的字段/方法是可能的,但它似乎不适用于方法。 到目前为止,答案中没有提到的另一件事。 where-clauses 还限制了其中定义的表达式的范围。 我也没有找到在 Scala 中实现这一目标的方法。 回答1 在 Hakell 中,where 子句保存函数的局部定义。 Scala 没有显式的 where 子句,但可以通过使用局部var 、 val和def来实现相同的功能。 本地`var`和`val` 规模: def foo(x: Int, y: Int): Int = { val a = x + y var b = x * y a - b } 在哈斯克尔: foo :: Integer -> Integer -> Integer foo x y = a - b where a = x + y b = x * y 本地`def` 在斯卡拉 def foo(x
  • In Haskell, when do we use in with let?
    In the following code, the last phrase I can put an in in front. Will it change anything? Another question: If I decide to put in in front of the last phrase, do I need to indent it? I tried without indenting and hugs complains Last generator in do {...} must be an expression import Data.Char groupsOf _ [] = [] groupsOf n xs = take n xs : groupsOf n ( tail xs ) problem_8 x = maximum . map product . groupsOf 5 $ x main = do t <- readFile "p8.log" let digits = map digitToInt $concat $ lines t print $ problem_8 digits Edit Ok, so people don't seem to understand what I'm saying. Let me rephrase
  • Haskell: Where vs. Let
    I am new to Haskell and I am very confused by Where vs. Let. They both seem to provide a similar purpose. I have read a few comparisons between Where vs. Let but I am having trouble discerning when to use each. Could someone please provide some context or perhaps a few examples that demonstrate when to use one over the other? Where vs. Let A where clause can only be defined at the level of a function definition. Usually, that is identical to the scope of let definition. The only difference is when guards are being used. The scope of the where clause extends over all guards. In contrast, the
  • 在Haskell中派生如何工作?(How does deriving work in Haskell?)
    问题 Haskell中的代数数据类型(ADT)可以从它们派生而自动成为某些类型类(例如Show , Eq )的实例。 data Maybe a = Nothing | Just a deriving (Eq, Ord) 我的问题是,此deriving如何工作,即Haskell如何知道如何为派生的ADT实现派生的类型类的功能? 另外,为什么deriving仅限于某些类型类? 为什么我不能编写自己的可以派生的类型类? 回答1 简短的答案是魔术:-)。 也就是说,自动派生已纳入Haskell规范中,每个编译器都可以选择以自己的方式实现它。 但是,如何使它可扩展有很多工作。 Derive是Haskell允许您编写自己的派生机制的工具。 GHC曾经提供了一个称为Generic Classes的可派生类型类扩展,但是由于它有些弱,因此很少使用。 现在已经将其删除,并且正在进行整合本文所描述的新的通用派生机制的工作:http://www.dreixel.net/research/pdf/gdmh.pdf 有关更多信息,请参见: GHC Wiki:http://hackage.haskell.org/trac/ghc/wiki/Commentary/Compiler/GenericDeriving Haskell Wiki:http://www.haskell.org/haskellwiki
  • 什么是“n+k 模式”,为什么它们被 Haskell 2010 禁止?(What are “n+k patterns” and why are they banned from Haskell 2010?)
    问题 在阅读维基百科关于 Haskell 2010 的条目时,我偶然发现了这一点: -- using only prefix notation and n+k-patterns (no longer allowed in Haskell 2010) factorial 0 = 1 factorial (n+1) = (*) (n+1) (factorial n) “n+k 模式”是什么意思? 我想这是第二行,但我不明白这可能有什么问题。 任何人都可以解释那里的问题是什么? 为什么 Haskell 2010 中不允许这些 n + k 模式? 回答1 什么是 n+k 模式? 看看这个: $ ghci GHCi, version 6.12.3: http://www.haskell.org/ghc/ :? for help Loading package ghc-prim ... linking ... done. Loading package integer-gmp ... linking ... done. Loading package base ... linking ... done. Loading package ffi-1.0 ... linking ... done. Prelude> let f 0 = 0 ; f (n+5) = n Prelude> :t f f
  • In Haskell, what is the scope of a where clause when dealing with guards?
    I know they do not hold across pattern matches (i.e. you need to rewrite the 'where' clause for each pattern), but how does the scoping work for guards? e.g. Does this work? myFunction x1 x2 | x1 > x2 = addOne x1 | x1 < x2 = addOne x2 | otherwise = x1 where addOne = (1+) Or should it be this? myFunction x1 x2 | x1 > x2 = addOne x1 where addOne = (1+) | x1 < x2 = addOne x2 where addOne = (1+) | otherwise = x1
  • Haskell - 在模式匹配中使用常量(Haskell - Using a constant in pattern matching)
    问题 假设我有以下代码( <>中的文本是速记,实际上不是代码的一部分): data A = <something> defaultA :: A defaultA = <Really complicated expression of type A> 现在我想在defaultA上有一个函数模式匹配,如下所示: f defaultA = <case 1> f _ = <case 2> 但是,第一行中的defaultA变成了一个新变量,而不是意味着参数等于defaultA 。 我所知道的实现我想要的东西的最好方法是: f x | x == defaultA = <case 1> f _ = <case 2> 有人知道更好的方法吗? 回答1 如果defaultA仅包含构造函数调用,则可以使用模式同义词。 {-# LANGUAGE PatternSynonyms #-} data A = A Int pattern DefaultA = A 3 isDefaultA DefaultA = putStrLn "it was a default" isDefaultA _ = putStrLn "it was not a default" 不过,这并不是PatternSynonyms一个特别惯用的部署。 我可能会坚持使用 Haskell 98,使用稍微更详细的保护子句和相等测试。 data A
  • Haskell: Deriving Show for custom type
    I have this type definition: data Operace = Op (Int->Int->Int) String (Int->Int->Int) deriving Show I want to print this type into the interactive shell (GHCi). All that should be printed is the String field. I tried this: instance Show Operace where show (Op op str inv) = show str But I still keep getting No instance for (Show (Int -> Int -> Int)) arising from the 'deriving' clause of a data type declaration Possible fix: add an instance declaration for (Show (Int -> Int -> Int)) or use a standalone 'deriving instance' declaration, so you can specify the instance context yourself When
  • Haskell中的“块”粒度如何定义?(How is 'block' granularity in Haskell defined?)
    问题 我注意到在Haskell中这是不合法的: foo :: [a] -> [a] foo [] = [] bar = 3 foo (x:xs) = x : foo xs 但是,这是: foo :: [a] -> [a] bar = 3 foo [] = [] foo (x:xs) = x : foo xs 尽管必须将与某个功能匹配的模式全部组合为一个集合,但似乎类型签名可能会漂移。 但是要走多远? 有人告诉我它必须在同一“块”中……但是从技术上讲,“块”到底是什么? 回答1 每个函数的声明必须在一起,但声明可以以任何顺序出现在文件中。 Haskell报告的声明部分在第4.4.3.1节“函数绑定”中说: 请注意,所有定义函数的子句必须是连续的,并且每个子句中的模式数必须相同。 与每个匹配相对应的模式集必须是线性的-不允许变量在整个集合中出现多次。 您有四个顶级声明: bar声明 bar = 3 foo两个声明 foo [] = [] foo (x:xs) = x : foo xs foo的类型签名 foo :: [a] -> [a] 除了函数绑定的连续声明之外,它们在同一文件中的顺序可以彼此任意距离,并且具有相同的含义。 让和在哪里 let和where还会引入非顶级声明。 在这些声明范围中,除了函数的连续声明外,声明可以按任何顺序发生并且仍然具有相同的含义。
  • 仅使用monadic绑定语法来表达do块(Expressing do block using only monadic bind syntax)
    问题 据我所知,Haskell中的do块仅仅是Monadic绑定运算符的某种语法糖。 例如,一个可以转换 main = do f <- readFile "foo.txt" print f print "Finished" 至 main = readFile "foo.txt" >>= print >> print "Finished" 都可以do块转换的绑定语法? 例如,该块多次使用f情况如何: main = do f <- readFile "foo.txt" print $ "prefix " ++ f print $ f ++ " postfix" 假设我们在IO monad中,则不可能简单地两次执行readFile计算。 如何仅使用绑定语法来表达此示例(如果可能的话)? 我认为使用Control.Monad并不是解决方案,因为它内部使用了do块。 我认为可以使用箭头(使用&&& )来表达这一点-也许在这种情况下,只有箭头可以用作monad的泛化? 请注意,此问题与上面的特殊示例无关,而与在诸如print单子表达式中多次使用计算结果的一般情况有关。 回答1 是的,所有这些都可以转换为绑定语法; 实际上,它们是由编译器内部转换的。 我希望您的示例的翻译能够给您提示: main = readFile "foo.txt" >>= \f -> (print $ "prefix "
  • Scala equivalent to Haskell's where-clauses?
    Is it possible to use something similar to where-clauses in Scala? Maybe there is some trick I didn't think of? Edit: Thanks for all your answers, they are very much appreciated. To sum up: Local vars, vals and defs can be used to achieve almost the same thing. For lazy evaluation, one can use lazy val (with implicit caching) or function definitions. Ensuring functional purity is left to the programmer. Now just one question remains: Is there a way of putting the value or function definitions after the expressions they are used in? Sometimes that seems a lot clearer. This is possible with
  • Python中的记忆斐波那契算法(Memoization fibonacci algorithm in python)
    问题 我有这种记忆技术,可以减少获得斐波那契序列号的呼叫数量: def fastFib(n, memo): global numCalls numCalls += 1 print 'fib1 called with', n if not n in memo: memo[n] = fastFib(n-1, memo) + fastFib(n-2, memo) return memo[n] def fib1(n): memo = {0:1, 1:1} return fastFib(n, memo) numCalls = 0 n = 6 res = fib1(n) print 'fib of', n,'=', res, 'numCalls = ', numCalls 但是我被memo[n] = fastFib(n-1, memo) + fastFib(n-2, memo) : memo[n] = fastFib(n-1, memo) + fastFib(n-2, memo) ,这里memo = {0:1, 1:1} 。 每次我想获取数字fib时,如何确切地减少通话数量? 回答1 您应该始终返回memo[n] ,不仅要在不安全的查找上( fastFib()最后一行): def fastFib(n, memo): global numCalls numCalls += 1 print
  • Haskell的隐藏功能(Hidden features of Haskell [closed])
    问题 从目前的情况来看,这个问题不适合我们的问答形式。 我们希望答案得到事实,参考或专业知识的支持,但是这个问题可能会引起辩论,争论,民意测验或进一步的讨论。 如果您认为此问题可以解决并且可以重新提出,请访问帮助中心以获取指导。 9年前关闭。 已锁定。 该问题及其答案被锁定,因为该问题是题外话,但具有历史意义。 它目前不接受新的答案或互动。 Haskell编程语言鲜为人知但有用的功能是什么? (我知道这种语言本身鲜为人知,但是可以和我一起工作。即使我对Haskell中简单的事情的解释,例如用一行代码定义斐波那契数列,也会被我所接受。) 尝试将答案限制在Haskell核心每个答案一项功能给出该功能的示例和简短描述,而不仅仅是指向文档的链接使用粗体标题作为第一行标记功能 回答1 我的大脑刚刚爆炸 如果您尝试编译此代码: {-# LANGUAGE ExistentialQuantification #-} data Foo = forall a. Foo a ignorefoo f = 1 where Foo a = f 您将收到以下错误消息: $ ghc Foo.hs Foo.hs:3:22: My brain just exploded. I can't handle pattern bindings for existentially-quantified constructors
  • 在Haskell中派生Eq和Show作为类型别名(Derive Eq and Show for type alias in Haskell)
    问题 我有以下类型别名 data Bindable = Const Value | Variable Location | Func Function | Proc deriving (Eq, Show) type Function = Argument -> Store -> Value 但是编译器给我一个错误 No instance for (Show Function) arising from the 'deriving' clause of a data type declaration Possible fix: add an instance declaration for (Show Function) or use a standalone 'deriving instance' declaration, so you can specify the instance context yourself When deriving the instance for (Show Bindable) 我可以为功能定义Show&Eq吗? 如果没有,那么解决方案是什么? 我应该定义等式并显示为参数,存储和值吗? 回答1 型类实例可以仅对于“真正的”类型来定义,由定义data或newtype声明。 type声明是“伪”类型,只是较长类型的缩写。 但这只是问题#1的问题。
  • Haskell:将列表转换为数据(Haskell: Convert list to data)
    问题 我有很多这样的代码: data Post = Post { postOwner :: Integer , postText :: ByteString , postDate :: ByteString } sqlToPost :: [SqlValue] -> Post sqlToPost [owner, text, date] = Post (fromSql owner) (fromSql text) (fromSql date) (这里使用的库是 HDBC)。 将来会有很多像Post这样的数据和像sqlToVal这样的sqlToVal 。 我可以减少sqlToVal样板代码吗? 回答1 模板 Haskell 代码生成是一个非常高级的主题。 尽管如此,如果您掌握了 TH 的艺术,则可以使用上述技术来生成您正在寻找的代码。 请注意,以下代码仅适用于只有一个构造函数的data类型(例如 not data Foo = A String Int | B String Int ,它有两个构造函数A和B ),因为您没有在代码。 我们将创建一个在编译时运行的 Template Haskell 函数,获取数据类型的名称,并生成一个名为sqlTo<nameofdatatype>的函数。 这个函数看起来像这样: module THTest where import Control.Monad
  • 为什么在 where 子句中使用类型签名如此罕见?(Why is it so uncommon to use type signatures in where clauses?)
    问题 它是否有助于编译器进行优化,还是添加额外的类型签名只是多余的工作? 例如,人们经常看到: foo :: a -> b foo x = bar x where bar x = undefined 而不是: foo :: a -> b foo x = bar x where bar :: a -> b bar x = undefined 如果我省略顶级类型签名,GHC 会给我一个警告,所以如果我没有收到警告,我非常有信心我的程序是正确的。 但是,如果我省略 where 子句中的签名,则不会发出警告。 回答1 如果子表达式在定义中出现多次, where子句中的定义通常是为了避免重复。 在这种情况下,程序员将本地定义视为写出内联子表达式的简单替代品。 您通常不会显式键入内联子表达式,因此也不键入where定义。 如果您这样做是为了节省打字时间,那么类型声明将耗尽您所有的节省。 用这种形式的例子向 Haskell 的学习者介绍where似乎很常见,所以他们继续认为“正常风格”是不为局部定义提供类型声明。 至少,这是我学习 Haskell 的经验。 从那以后我发现,如果我不知道本地定义的类型,我的许多足够复杂的函数需要一个where块变得相当难以理解,所以我现在尝试错误地总是输入它们; 即使我在编写代码时认为类型很明显,但当我在一段时间没有看它之后阅读它时,它可能不那么明显。
  • 导出模板 haskell 生成的定义(Export template haskell generated definitions)
    问题 我的模块包含定义,其中一部分被导出(在module子句中)。 我也想导出模板 Haskell 生成的声明。 但是由于似乎没有办法用 TH 修改module子句,我不能这样做。 是否可以指定完全导出 TH 生成的声明? 或者也许还有其他方法可以做到这一点? 回答1 您需要导出生成的 TH 声明的名称。 例如,如果您有一个 TH 函数生成data B = C | D data B = C | D声明,您只需导出module Mymodule (B(C,D)) where ... 。 如果您不指定导出列表,则将导出该模块中的所有声明。 您可以做的一个小技巧是将所有生成的 TH 函数放在一个模块中,然后重新导出该模块: {-# LANGUAGE TemplateHaskell #-} -- Put all of the generated stuff in one module module Bla.Generated where generateAFunctionCalled "foo" generateAFunctionCalled "bar" -- Re-export the generated module module Bla (module Bla.Generated) where import qualified Bla.Generated
  • Haskell解析器到AST数据类型,分配(Haskell parser to AST data type, assignment)
    问题 我已经在互联网上搜寻了几天,试图得到我的问题的答案,我终于承认失败了。 我得到了一个语法: Dig ::= 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 Int ::= Dig | Dig Int Var ::= a | b | ... z | A | B | C | ... | Z Expr ::= Int | - Expr | + Expr Expr | * Expr Expr | Var | let Var = Expr in Expr 有人告诉我使用这种语法来分析,评估和打印表达式运算符* + -具有其正常含义具体的任务是编写一个函数parse :: String -> AST 它以字符串作为输入,并在输入格式正确时返回抽象语法树(我可以假设是)。 有人告诉我,我可能需要合适的数据类型,并且该数据类型可能需要从其他一些类派生。 跟随示例输出data AST = Leaf Int | Sum AST AST | Min AST | ... 此外,我应该考虑编写一个函数tokens::String -> [String] 将输入字符串拆分为令牌列表解析应使用ast::[String] -> (AST,[String]) 其中输入是令牌列表,并且输出AST,并且要解析子表达式,我应该简单地递归使用ast函数。
  • Export template haskell generated definitions
    My module contains definitions, part of which are exported (in module clause). I want to export Template Haskell-generated declarations too. But since there is seemingly no way to modify module clause with TH, I cannot do this. Is it possible to specify that TH-generated declarations should be exported at all? Or maybe there are other ways to do this?
  • Haskell opengl texture GLFW
    I have been trying to get some script that just displays a texture on a square using texcoords. If possible can you edit the script so that it works as from there I can workout how you did it as thats how I learn. import Control.Monad (unless, when) import Graphics.Rendering.OpenGL import qualified Graphics.UI.GLFW as G import System.Exit import System.IO import Texture import Data.IORef import Graphics.GLUtil import qualified Data.Set as Set main :: IO () main = do let errorCallback err description = hPutStrLn stderr description G.setErrorCallback (Just errorCallback) successfulInit <- G.init