小编dfe*_*uer的帖子

我正在实现Ukkonen的算法,它要求树的所有叶子都包含对同一整数的引用,并且我在Haskell中这样做以了解有关该语言的更多信息.但是,我很难写出执行此操作的数据类型.

-- Node has children, indexes of info on the edge
-- to it, and an optional suffix link.

-- Leaf has a beginning index of the info, but the
-- end index is always an incrementing variable index.
data STree = Node [STree] (Int, Int) (Maybe STree)
           | Leaf (Int, ??? )

如何将引用放在Leaf类型声明中？

我刚刚从最新的来源安装了GHC,现在我的程序给了我一个关于"关闭句柄的延迟读取"的错误消息.这是什么意思？

问题：实现一个名为 stripComments(code) 的 Python 函数，其中 code 是一个参数，它采用包含 Python 代码的字符串。函数 stripComments() 返回删除所有注释的代码。

我有：

def stripComments(code):
   code = str(code)
   for line in code:
       comments = [word[1:] for word in code.split() if word[0] == '#']
       del(comments)
stripComments(code)

我不确定如何具体告诉 python 搜索字符串的每一行，并在找到主题标签时删除该行的其余部分。请帮忙。:(

aeson似乎采用了一种有点简单的方法来解析JSON:它将顶级JSON值(一个对象或数组)解析为它自己的固定表示,然后提供帮助用户将该表示转换为它们自己的工具.当JSON对象和数组很小时,这种方法非常有效.当它们非常大时,事情开始崩溃,因为在完全读取和解析JSON值之前,用户代码无法执行任何操作.这似乎特别不幸,因为JSON似乎是为递归下降解析器设计的 - 似乎应该相当简单,允许用户代码介入并说明每个部分应该如何解析.有没有深层原因aeson和早期的json工作方式,或者我应该尝试创建一个新库以进行更灵活的JSON解析？

pigworker曾经问过如何表达一种类型是无限可分的.这个问题让人联想到这样一个事实:在复杂的分析中,一个可微分的函数(在开集上)必须是无限可微的(在那个集合上).有没有办法谈论数据类型的复杂差异？如果是这样,类似的定理是否成立？

我注意到,测试套件Data.Set只有真正定义Arbitrary Set a合理的a ~ Int,但要避免GHC特殊~,它使用

instance Enum a => Arbitrary (Set a)

如何在Arbitrary (Set Int)不需要任何GHC扩展的情况下确保仅使用实例？在GHC-唯一代码,我会请使用FlexibleInstances或GADTs再任

instance Arbitrary (Set Int)

要么

instance a ~ Int => Arbitrary (Set a)

Control.Monad.Morph 包括

class MFunctor t where
  hoist :: Monad m => (forall a. m a -> n a) -> t m b -> t n b

据我所知,所包含的实例都没有使用Monad m约束.怎么可能这样做？是否有使用约束的有效实例(考虑到这一点,我有点难以想象hoist id = id)？约束的意义是什么,m而不是n？

用户2426021684的评论让我调查是否有可能提出一个类型函数,以证明对于某些和:FF c1 c2 fafa

1. fa ~ f a
2. c1 f
3. c2 a

事实证明,最简单的形式很容易.但是,我发现很难弄清楚如何编写多角度版本.幸运的是,当我写这个问题时,我设法找到了一种方法.

流包定义

data Stream f m r = Step !(f (Stream f m r))
                  | Effect (m (Stream f m r))
                  | Return r

它的实施empty,被称为never,被定义

never :: (Monad m, Applicative f)
      => Stream f m r
never = let loop = Effect (return (Step (pure loop))) in loop

对于基本上纯粹的东西来说,这都是非常单一的,这是图书馆通常为了性能原因而试图避免的.显而易见的纯粹版本将是

never = let loop = Step (pure loop) in loop

不幸的是,既然Step是严格的,这将会成为一个严格的仿函数pure,例如Identity.有没有办法解决？我唯一的想法是荒谬的不安全,我不知道它是否会出现可怕的错误.

data StreamL f m r = StepL (f (StreamL f m …

从类别理论的角度来看,这个答案包括以下声明:

......事实是,co和逆变函数之间没有真正的区别,因为每个函子只是一个协变函子.

...

更详细地说,从类别C到类别D的逆变函数F只不过是F类型的(协变)函子:C ^op →D,从C的相反类别到类别D.

在另一方面,Haskell的Functor和Contravariant仅仅需要fmap和contramap,分别为实例来定义.这表明,从Haskell的角度来看,存在Contravariant但不是Functors的对象(反之亦然).

因此,似乎在类别理论中"co和逆变函子之间没有真正的区别",而在Haskell中,Contravariant和之间有区别Functor.

我怀疑这种差异与Haskell在Hask中发生的所有实现有关,但我不确定.

我认为我自己理解每个类别理论和Haskell的观点,但我很难找到连接两者的直觉.