标签: ghc

假设我有以下功能

small_div :: Int -> Int
small_div n = filter (\x -> n `rem` x == 0) [2..n] !! 0

这个函数的内存使用情况是多少？等效的C代码将是恒定的内存使用量,我相信Haskell的懒惰评估意味着它不会创建[2..n]的更多元素而不是找到第一个除数所需的元素,但ghc足够聪明才能进行跳转像...这样的东西

int small_div(int n) {
    for (int x = 2; x <= n; x++) {
        if (n % x == 0) {
            return x;
        }
    }
}

GHC在这一点上的速度惊人地快.不过,我对Haskell的类型系统不满意,所以我决定将自己的系统作为DSL来实现.现在,我想通过翻译后检查无类型lambda演算表达式来编译我的语言到Haskell,以便使用GHC的性能.唯一的问题是我的系统上的某些有效表达式无法在GHC上编译.我怎样才能避免这个问题 - 即通过告诉GHC完全禁用类型系统"我已经检查了这个,相信我"？

我一直在关注GHC.Generics教程,制作一个简单的通用类型类,为任意类型提供默认值.但是,当我尝试加载我的文件(相关片段,仍然产生错误)

{-# LANGUAGE DefaultSignatures, DeriveGeneric, TypeOperators, FlexibleContexts #-}
import GHC.Generics

class Default a where
    def :: a
    default def :: (Generic a, GDefault (Rep a)) => a
    def = to gdef

class GDefault f where
    gdef :: f a

instance (Default a, Default b) => GDefault (a :+: b) where
    gdef (L1 x) = gdef x
    gdef (R1 x) = gdef x

我收到以下错误:

Generic.hs:12:46:
    The first argument of ‘:+:’ should have kind ‘* -> *’,
      but ‘a’ has …

我有这样toAVector定义的函数:

class Elt a => ToAVector v a where
  toAVector :: v a -> A.Array DIM1 a

instance Elt a => ToAVector [] a where
  toAVector l =
    A.fromList (Z :. P.length l) l

instance (Elt a, G.Vector v a) => ToAVector v a where
  toAVector v =
    A.fromFunction (Z :. G.length v) (\(Z :. i) -> v G.! i)
  {-# INLINE toAVector #-}

当试图toAVector在另一个库中使用时,我收到错误:

Overlapping instances for ToAVector [] Double
  arising from a use of …

我正在和Alex和Happy一起构建一个词法分析器和解析器.他们生成的代码ghc-options: -Wall在我的项目的.cabal文件中打开时会抛出大量的警告.

这使得很难捕捉到真正的警告.如何仅在生成的文件中关闭警告？我知道可以用pragma完成:

{#- GHC_OPTIONS -w -#}

但是我想不出一个简单的方法可以在每次生成的文件的顶部粘贴这个pragma,每次重建它们.

这样做的正确方法是什么？

在unsafeDupablePerformIO(来源,文档)的定义中,我找到了对唯一的引用realWorld#.所以我想知道所有这些以a结尾的函数或值是在哪里#定义的？我已经找到了GHC primops课程:它们包括seq#,catch#,retry#,和所有其他类型的有趣功能.它还包含一种RealWorld类型.但是这些初学者似乎并没有包含实际价值realWorld#.

{-# NOINLINE unsafeDupablePerformIO #-}
    -- See Note [unsafeDupablePerformIO is NOINLINE]
unsafeDupablePerformIO  :: IO a -> a
unsafeDupablePerformIO (IO m) = lazy (case m realWorld# of (# _, r #) -> r)
     -- See Note [unsafeDupablePerformIO has a lazy RHS]

(请不要混合RealWorld和realWorld#:第一个是类型,第二个是值.)

GHC还有其他未记载的初学者吗？或者也许所有这些都记录在某处,我还没有找到它？我可以在GHC源中查看这些内容的实现情况吗？

以下代码导致错误:

{-# LANGUAGE GeneralizedNewtypeDeriving, MultiParamTypeClasses, StandaloneDeriving #-}

class Module a b where
    (*>) :: a -> b -> b

data D
newtype DWrapper = DW D    
instance Module D D    
deriving instance Module DWrapper DWrapper

错误:

No instance for (Module DWrapper D) arising from a use of ‘Main.*>’
In the first argument of ‘GHC.Prim.coerce’, namely
  ‘(Main.*>) :: DWrapper -> D -> D’
In the expression:
    GHC.Prim.coerce ((Main.*>) :: DWrapper -> D -> D) ::
      DWrapper -> DWrapper -> DWrapper
In …

我的程序就像是

main :: IO String
main = do
  putStrLn "input a"
  a <- getChar
  putStrLn "input b"
  b <- getLine
  putStrLn "input c"
  c <- getChar
  return a:c:b

行为:打印出"输入a",程序等待我键入Char并按回车键.从那里,它滚过getLine而不让我输入一些东西.我怎样才能让它按照我的意图去做呢？

PS:这段代码可能存在更多问题,但让我们关注我目前的问题.

为什么accursedUnutterablePerformIO(又名inlinePerformIO)实施

accursedUnutterablePerformIO :: IO a -> a
accursedUnutterablePerformIO (IO a) = case a realWorld# of (# _, r #) -> r

并不是

accursedUnutterablePerformIO :: IO a -> a
accursedUnutterablePerformIO (IO a) = case a realWorld# of (# s, r #) -> s `seq` r

？

{-# LANGUAGE DataKinds, ExistentialQuantification, KindSignatures #-}
import Data.Proxy

data Type t= forall (a :: t). Type (Proxy a)

给出了错误

Type variable ‘t’ used in a kind
In the kind ‘t’
In the definition of data constructor ‘Type’
In the data declaration for ‘Type’

但是t是一个Kind变量,而不是一个类型变量.这是怎么回事？