标签: ghc

我试图将关联类型与存在类型进行比较，并编写了以下片段：

{-# LANGUAGE FlexibleContexts #-}\n{-# LANGUAGE ExistentialQuantification #-}\n{-# LANGUAGE StandaloneDeriving #-}\n\nimport Prelude \n\ndata App = forall t. Eq t => App { f :: t }\n\nderiving instance Eq App  \n

类型检查吠叫：

\n

无法将预期类型 \xe2\x80\x98b\xe2\x80\x99 与实际类型 \xe2\x80\x98b1\xe2\x80\x99 \xe2\x80\x98b1\xe2\x80\x99 匹配\n刚性类型变量绑定

\n

乍一看，相同的代码片段是作为早期堆栈溢出的解决方案提供的。

我发现可能相关的 GHC问题，但禁用 PolyKinds 扩展没有任何效果，Polysemy 插件也没有。

使用 GHC 9.2.5。

聚苯乙烯

因此在实践中这两种方法都不支持推导。

Monoid如果我编写一个操作极其复杂的实例(<>)，GHC 会知道吗？

mempty <> x = x
x <> mempty = x

并避免计算(<>)？

我还对您如何获得该信息感兴趣，以及如果此优化不存在，这是否可以完成或之前已讨论过。

为什么-XImplicitParams从命令行工作而不是OPTIONS_GHC pragma？

我发现ghc t.hs抛出一个parse error on input 'a'if t.hs包含以下代码,同时ghc -XImplicitParams t.hs工作正常.同上ghci.

{- OPTIONS_GHC -XImplicitParams -}
f :: (?a :: Int) => Int -> Int
f b = ?a + b
g c = f $ c+1

从Haskell输出PostScript文件有哪些库/模块？越简单易用越好.我需要的唯一两个功能是绘制点和线的能力.

考虑这个简单的"基准":

n :: Int
n = 1000
main = do
    print $ length [(a,b,c) | a<-[1..n],b<-[1..n],c<-[1..n],a^2+b^2==c^2]

和适当的C版本:

#include <stdio.h>

int main(void)
{
    int a,b,c, N=1000;
    int cnt = 0;

    for (a=1;a<=N;a++)
        for (b=1;b<=N;b++)
            for (c=1;c<=N;c++)
                if (a*a+b*b==c*c) cnt++;
    printf("%d\n", cnt);
}

汇编:

• Haskell版本编译为:ghc -O2 triangle.hs(ghc 7.4.1)
• C版编译为:gcc -O2 -o triangle-c triangle.c(gcc 4.6.3)

运行时间:

• Haskell:4.308s真实
• C:1.145s真实

即使对于如此简单且可以很好地优化的程序,Haskell的速度几乎要慢4倍,这是不是很好？Haskell在哪里浪费时间？

我有一些简单的代码以固定的时间间隔打印到屏幕上,除非IORef设置为指示用户当前正在键入:

import Data.IORef
import Control.Concurrent

main = do
   amTyping <- newIORef False
   forkIO $ printALot amTyping
   aChar <- getChar
   writeIORef amTyping True
   aLine <- getLine
   writeIORef amTyping False
   putStrLn $ aChar : aLine
   main

printALot :: IORef Bool -> IO ()
printALot theRef = do
   putStrLn "1111111"
   threadDelay 1000000
   isTyping <- readIORef theRef
   if isTyping
      then return ()
      else printALot theRef

这在GHCi中运行得非常好,但是当我使用runghc(或编译它)时,读取或写入IORef似乎不起作用 - printALot只是继续循环,超越用户键入的任何内容.

ghci和runghc /编译之间有什么区别？我IORef是错误的,但没有注意到因为ghci不是真正的多线程？

float2Int似乎介于溢出2^^62,并2^^63为64位机器(我用GHC 7.6.1试图在英特尔的iMac).试图检查时,我才注意到这个问题maxBound了Int.在GHC中float2Int作为一个原始实现float2Int#.

GHCI提示输出低于- maxBound::Int是2^^63我的Intel Mac上.我也试过铸造2^^63到Float,然后还原值一点,看是否溢出消失(以考虑小舍入误差如果有的话).它没有:

?: maxBound :: Int
9223372036854775807
?: GHC.Float.float2Int $ 2^^63 -- overflows
-9223372036854775808
?: GHC.Float.float2Int $ (9223372036854775807::Float) -- now try actual value of 2^^63
-9223372036854775808
?: GHC.Float.float2Int $ (9223372036854000000::Float)  -- reduce it a bit
-9223372036854775808
?: minBound :: Int -- overflow value is same as minBound::Int
-9223372036854775808
?: GHC.Float.float2Int $  2^^62 + 2^^61 -- works fine …

我有以下Haskell程序:

catlines = unlines . zipWith (\(n,l) -> show n ++ l) [0..]

main = putStrLn $ catlines ["A", "B"]

当我尝试编译它时,GHC给出以下错误:

catlines.hs:1:41:
    Couldn't match expected type `b0 -> String' with actual type `[a0]'
    In the expression: show n ++ l
    In the first argument of `zipWith', namely
      `(\ (n, l) -> show n ++ l)'
    In the second argument of `(.)', namely
      `zipWith (\ (n, l) -> show n ++ l) [0 .. ]'

据我所知,这应该编译.我不知道出了什么问题.

我目前正在学习Haskell(我的问题很多都是从最近的这个声明开始)而且由于语法错误而导致编译程序的问题,主要是识别错误,理解/解决GHC提供的错误消息.

例如,它只是花了我很长时间来解决下面代码中的错误.请记住,这是从Haskell教程书中获取的:

getNums = do
    putStrLn "enter a number (0 to terminate)"
    num <- getLine
    if read num == 0
    then return []
    else do rest <- getNums
    return ((read num :: Int):rest)

GHCI输出错误消息也没有真正帮助:

Number.hs:18:17:
    The last statement in a 'do' block must be an expression
      rest <- getNums

我目前正在通过Linux终端运行GHCI并手动编译,用gedit编写的代码.我的问题是:

是否有更好的环境或设置可以为像我这样的初学者提供更深入的编译时错误解释？

即类似于NetBeans IDE将提供关于为什么代码在语法上不正确的提示/提示的方式？

我要做的最后一件事就是在SO上粘贴一个代码块,并且是那个说"为我解决这个问题"的白痴

编辑

我很欣赏这可能不被归类为一个非常好的问题,因为它基本上要求人们提出意见.

我有一个明确的尾递归函数用于查找(选择nk)mod10007(k非负)

为什么这个函数会为大输入消耗大量内存？(即100000000选择50000000)我可以理解它是否可能很慢,但它不应该使用超过常量内存,应该吗？(假设GHC知道尾调优化)

GHC版本7.8.3

modulus :: Int
modulus = 10007

choose :: Int -> Int -> Int
choose n1 k1
    | s1 > 0 = 0
    | otherwise = q1
  where
    (q1, s1) = doChoose n1 k1 (1, 0)
    doChoose :: Int -> Int -> (Int, Int) -> (Int, Int)
    doChoose _ 0 (qr, sr) = (qr, sr)
    doChoose n k (qr, sr) =
        doChoose (n `seq` (n-1)) (k-1) (qr `seq` (qn * qr `rem` modulus * inv qk …