小编dan*_*iaz的帖子

在对这个问题的评论中,已经提到嵌套几层FreeT变换器(每个变换器都有不同的仿函数)可以起到与"数据类型单点"方法类似的目的(尽管使用副产品组合了仿函数)这两种方法不同构.

我的问题是:差异在哪里？是否存在一种方法可以处理的情况,而不是另一种方法？他们是否承认不同的口译员？

更新:这是嵌套FreeT变换器的一个简单示例.通过发出日志消息和请求延迟的能力来扩充计算:

import Data.Functor.Identity
import Control.Monad
import Control.Monad.Trans
import Control.Monad.Trans.Free
import Control.Concurrent

type Delay = Int

type DelayT = FreeT ((,) Delay)

delay ::  Monad m => Delay -> DelayT m ()
delay t = liftF (t,()) 

type Message = String

type LogT = FreeT ((,) Message)

emitLog :: Monad m => Message -> LogT m ()
emitLog msg = liftF (msg,()) 

type Effected = DelayT (LogT Identity) …

看看SQLException javadocs,getCause和之间似乎有重叠getNextException.第一个返回Throwable,但是否则它们似乎几乎可以互换.

两者有什么区别？在开发JDBC驱动程序时,是否有关于何时选择其中一个作为异常链接机制的指导原则？

我正在使用这个aeson包.我有一个Data.Tree在其声明中使用的数据类型.如下所示,只是更复杂:

 data Foo = Foo {
               bat :: Text 
             , xux :: Maybe Text 
             , tri :: Tree Text
            }

我想用来为这种类型Data.Aeson.TH生成一个FromJSON实例.

$(deriveJSON defaultOptions ''Foo)

但是Data.Tree没有标准实例FromJSON,这意味着我需要声明一个孤儿实例.

有没有办法避免创建该孤立实例,同时仍能使用deriveJSON？

在Data.Primitive.SmallArray，有函数：

indexSmallArray## :: SmallArray a -> Int -> (#a#)

它以单元素未装箱的 tuple返回其结果。

我的问题是：我们从返回未装箱的元组中获得什么？为什么不简单地返回a？

我确实得到了多个元素的未装箱元组的用处。正如Levity Polymorphism论文所说：

最初设想支持从函数返回多个值，未装箱的元组只是用于将多个值绑定在一起的 Haskell 语法。未装箱的元组在运行时根本不存在 [...] 在编译期间，未装箱的元组被完全擦除

这似乎是人为的，但是我似乎找不到以下答案：

说我有以下进口：

import qualified Data.Map as M
import qualified Data.HashMap.Lazy as HML

现在，我有了一些函数（comp），该函数需要一些列表，执行某些操作，创建地图并返回它。

我的问题是我如何有两种调用方式，comp以便正确调用insert并size映射？

作为一名稻草人，我可以编写此函数的两个副本，一个引用M.insert和M.size，而另一个引用HML.insert和HML.size...，但是我如何“将模块作为参数传递”，或者另外指出呢？

谢谢！

编辑：为了使这个不太抽象，这些是的确切定义comp：

mapComp :: KVPairs -> IO ()
mapComp kvpairs = do
  let init = M.empty
  let m = foldr ins init kvpairs where
        ins (k, v) t = M.insert k v t
  if M.size m /= length kvpairs
  then putStrLn $ "FAIL: " ++ show …

在Hackage中是否存在一个类似于MonadIO但是对于Applicatives 的类型类,它允许人们轻松地将IO动作提升到 基于的"应用组合堆栈"IO？

如果存在这样的类型类,是否会因实施" 申请Monad提案"而过时？该提案是否涉及放宽Monad约束MonadIO？

我试图了解Selectmonad是如何工作的.显然,它是表兄,Cont它可以用于回溯搜索.

我有这个基于列表的解决n-queens问题的方法:

-- All the ways of extracting an element from a list.
oneOf :: [Int] -> [(Int,[Int])] 
oneOf [] = [] 
oneOf (x:xs) = (x,xs) : map (\(y,ys) -> (y,x:ys)) (oneOf xs)

-- Adding a new queen at col x, is it threathened diagonally by any of the
-- existing queens?
safeDiag :: Int -> [Int] -> Bool
safeDiag x xs = all (\(y,i) -> abs (x-y) /= i) (zip xs [1..])

nqueens :: Int …

我有这个（公认的奇怪）代码，它使用了lens和GHC.Records：

{-# LANGUAGE DataKinds, PolyKinds, FlexibleInstances, UndecidableInstances #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE TypeFamilies #-}
module Main where
import Control.Lens
import GHC.Records 

data Glass r = Glass -- just a dumb proxy

class Glassy r where
  the :: Glass r

instance Glassy x where
  the = Glass

instance (HasField k r v, x ~ r)
-- instance (HasField k r v, Glass x ~ Glass r) 
  => …

我有一个无限的结构,如下所示(使用流包中的Stream类型):

data U x = U (Stream x) x (Stream x) deriving (Functor,Foldable)             

我想为它提供一个Traversable实例,如下所示:

instance Traversable U where
    traverse f (U lstream focus rstream) = 
        let pairs =  liftA unzip 
                   . sequenceA . fmap (traversepair f) 
                   $ zip lstream rstream 
            traversepair f (a,b) = (,) <$> f a <*> f b
            rebuild c (u,v) = U u c v
        in rebuild <$> f focus <*> pairs

Data.Traversable的文档说它们代表了"可以从左到右遍历的数据结构类".但是我的定义不是从左到右遍历,而是向外遍历.我不得不把它定义这种方式是能够在后懒洋洋地提取双方值序列涉及操作兰德单子. …

我有一个在类型级列表上映射类型系列的最小工作示例(从单例库中剔除):

{-# language PolyKinds #-}
{-# language DataKinds #-}
{-# language TypeFamilies #-}
{-# language TypeOperators #-}

data TyFun :: * -> * -> *

data TyCon1 :: (k1 -> k2) -> (TyFun k1 k2 -> *)

type family Apply (f :: TyFun k1 k2 -> *) (x :: k1) :: k2
type instance Apply (TyCon1 f) x = f x

type family Map (f :: TyFun a b -> *) (as :: [a]) :: [b] where
    Map …