小编HTN*_*TNW的帖子

我有标准Vect类型:

module Vect where

data Nat = Z | S Nat
data Vect (n :: Nat) (a :: Type) where
  VNil :: Vect Z a
  VCons :: a -> Vect n a -> Vect (S n) a

我有这些功能:

foldVect :: forall (p :: Nat -> Type) n a.
            p Z ->
            (forall m. a -> p m -> p (S m)) ->
            Vect n a -> p n
foldVect n c = go
  where go :: forall l. …

如何将 Haskell 中的约束蕴涵编码为新约束？在我的示例中，我想要求每个都Functor c d f需要Obj c x暗示Obj c (f x). 我正在写约束forall x . Obj c x => Obj d (f x)。

{-# LANGUAGE AllowAmbiguousTypes       #-}
{-# LANGUAGE KindSignatures            #-}
{-# LANGUAGE MultiParamTypeClasses     #-}
{-# LANGUAGE RankNTypes                #-}
{-# LANGUAGE ScopedTypeVariables       #-}
{-# LANGUAGE TypeApplications          #-}
{-# LANGUAGE TypeFamilies              #-}
{-# LANGUAGE QuantifiedConstraints     #-}

import Prelude hiding (id, Functor, fmap)
import Data.Kind

class Category c where                            
  type Obj c a :: Constraint …

我正在使用C代码库

typedef void(* wl_notify_func_t) (struct wl_listener *listener, void *data) 

//...

struct wl_listener {
  struct wl_list link;
  wl_notify_func_t notify; //<-- I'd like to return this
};

并使用了Haskell代码

type NotifyFuncT = FunPtr (Ptr C'WlListener -> Ptr () -> IO ())

initializeMyCtx = C.context $ C.baseCtx <> C.funCtx <> mempty {
  C.ctxTypesTable = Data.Map.fromList [
     (C.Struct "wl_listener", [t|C'WlListener|])
  -- ...
  ,  (C.TypeName "wl_notify_func_t", [t|NotifyFuncT|])
  ]
}

someHaskellFunction :: Ptr C'WlListener -> IO NotifyFuncT
someHaskellFunction ptrToWlListener = do
  funPtr <- [C.block| wl_notify_func_t {return $(struct …

作为一名前C ++程序员，Haskell线程的行为令人困惑。请参考以下Haskell代码段：

import Control.Concurrent
import Control.Concurrent.MVar
import Data.Functor.Compose
import System.Random

randomTill0 :: MVar () -> IO () -- Roll a die until 0 comes
randomTill0 mV = do
    x <- randomRIO (0,65535) :: IO Int
    if 0 == x
        then putMVar mV ()
        else randomTill0 mV

main :: IO ()
main = do
    n <- getNumCapabilities
    mV <- newEmptyMVar
    sequence (replicate n (forkIO (randomTill0 mV)))
    readMVar mV
    putStrLn "Excution complete."

据我所知，Haskell的forkIO大致相当于C ++的std::async。在C ++中，我存储一个std::future由返回的std::async …

我写我自己的异类列表实现(我第一次读到异类列表在这里和我的实现非常相似,他们的)

{-# LANGUAGE GADTs, DataKinds, TypeOperators #-}

data HList a where
  (:>) :: a -> HList b -> HList (a ': b)
  Nil  :: HList '[]
infixr 6 :>

这很棒; 然而,一旦我发现自己正在使用这些异构列表,我发现自己经常想要表达一个每个类型属于特定类型类的想法.我天真的第一个解决方案是HList完全为每个新类型类重写数据类型.这是它的Eq(例如,它不是我唯一关注的类型类):

{-# LANGUAGE GADTs, DataKinds, TypeOperators #-}

data EqHList a where
  (:>) :: (Eq a) => a -> EqHList b -> EqHList (a ': b)
  Nil :: EqHList '[]
infixr 6 :>

这有很多问题.首先,我需要在每次需要新类型时重写它.此外,在我的旧异构列表上工作的函数不适用于新的异构列表.

我的下一个解决方案是使用空类型.

{-# LANGUAGE GADTs, DataKinds, TypeOperators, FlexibleInstances, FlexibleContexts #-}

data HList …

在 GHCI 中，我得到以下结果：

div (-7) ( 2) = -4
div ( 7) (-2) = -4
div (-7) (-2) =  3

mod ( 7)  ( 2) =  1
mod ( 7)  (-2) = -1
mod (-7)  ( 2) =  1
mod (-7)  (-2) = -1

并且div 4 (-3)是-2并且mod 4 (-3)是-2。

我无法理解如何获得这些结果。有什么法律或规则吗？什么是正确的计算步骤？