小编dfe*_*uer的帖子

我试图了解GHC中视图模式和模式保护之间的关系.模式防护似乎非常直观,而视图模式似乎有点令人困惑.有点看起来模式对于处理模式中的深层事物看起来更好,而模式保护可以更直观地重用视图,但我不太明白.

似乎直觉上很明显,以下法律应该成立:

traverse f . fmap g = traverse (f . g)

似乎直接适用的唯一Traversable法律是

fmap g = runIdentity . traverse (Identity . g)

这改变了问题

traverse f . runIdentity . traverse (Identity . g)

似乎具有适当形式的唯一法律适用于此是自然法则.然而,这是关于应用变换,我没有看到任何这些.

除非我遗漏了什么,否则唯一剩下的就是参数化证明,我还没有得到关于如何编写这些内容的线索.

我想知道我是否可以拥有一个数组(或基本上是一个表),其中每个元素都是一组不同类型的对象.我的意思是我想创建这样的东西(我知道它的语法不正确,只是想表明我的想法):

List<String, int, double, Date, ... , etc > list_name

我这样做是为了确保当我将所有这些信息保存到我的数据库时,我将把所有这些信息都放在数据库的同一条目中.这是因为我从不同的站点进行了一些网络抓取以收集所有这些数据,即在列表中,字符串可能来自站点A,int可能来自站点B等.我发现某些信息可能由于某些原因而错过(比如说,对于列表的特定元素,来自站点A的字符串可能会丢失,其他数据就在那里,非常好.).如果我将这些数据存储到单独的列表中,我恐怕会有一些不匹配的数据.

现在我的解决方案是创建一个类,比如ClassA:

ClassA{

public String info1
public int info2
public double info3
..
..
public wtever info

}

然后我会有一份ClassA列表

我想知道是否有更好的方法来实现这一目标？

什么是统一的类型时,由Haskell的类型推断合成器的类型c -> a -> b和(a -> b) -> c？

有人可以解释我如何解决它？

谢谢!

一种众所周知的替代配方Applicative(参见,例如,Typeclassopedia)是

class Functor f => Monoidal f where
  unit :: f ()
  pair :: f a -> f b -> f (a, b)

这导致法律看起来更像典型的身份和相关性法则,而不是你从中得到的法则Applicative,但只有当你通过对重新关联同构时才能工作.几个星期前考虑到这一点,我想出了另外两个避免这个问题的配方.

class Functor f => Fapplicative f where
  funit :: f (a -> a)
  fcomp :: f (b -> c) -> f (a -> b) -> f (a -> c)

class Functor f => Capplicative f where
  cunit :: Category (~>) => f (a ~> a)
  ccomp :: Category (~>) => f (b …

Bifunctor和Arrow方法之间有些重叠：

class Bifunctor p where
  first :: (a -> a') -> p a b -> p a' b
  second :: (b -> b') -> p a b -> p a b'
  bimap :: (a -> a') -> (b -> b') -> p a b -> p a' b'

class Arrow (~~>) where
  ...
  first :: (a ~~> a') -> (a, b) ~~> (a', b)
  second :: (b ~~> b') -> (a, b) ~~> (a, b')
  (***) :: …

我正在研究紧凑堆栈的想法——随着其大小的增加，其空间需求接近数组的空间需求。候选结构：

data Stack a
  = Empty
  | Zero (Stack a)
  | One !(SmallArray a) (Stack a)
  | Two !(SmallArray a) !(SmallArray a) (Stack a)
-- Invariant: the array size at depth `n` is `2^n`.

push :: a -> Stack a -> Stack a
push = pushA . pure

pushA :: SmallArray a -> Stack a -> Stack a
pushA sa Empty = One sa Empty
pushA sa (Zero more) = One sa more
pushA sa1 (One sa2 more) = Two …

我总是喜欢能够为我的代码编写属性测试。当该代码是 Template Haskell 时，我最感兴趣的是生成的代码的行为。直觉上，我希望能够写出类似的东西

import Test.QuickCheck

checkLift :: (Eq a, Lift a, Show a) => a -> Property
checkLift a = $$(liftTyped a) === a

prop_myLiftWorks :: MyType -> Property
prop_myLiftWorks = checkLift

不幸的是，Template Haskell 阶段的限制使得这种精确的方法完全不可能。生成的拼接必须单独编译才能运行。是否有一些简单的方法可以在测试套件中启动 GHC 实例（或对包执行某些操作ghc或haskell-language-server？）并对其进行拼接？

理想情况下，我希望能够使用声明拼接和表达式拼接。例如，要为 编写属性测试deriving-compat，我想要生成各种类型的任意数据类型声明，然后将 Template Haskell 派生的实例与 GHC 派生的实例进行比较。

我正在为我的公司开发一个ASP.net Web应用程序.有些用户在内部网络(Intranet)中使用此站点,有些用户使用Internet站点.我正在使用Windows身份验证模式.

我需要找到一种方法,不为Intranet用户提示 Windows身份验证模式,并为Internet用户提示 Windows身份验证模式.

我怎样才能做到这一点？

我在看如何inorder + preorder构造独特的二叉树？并认为在伊德里斯写一个正式的证据会很有趣.不幸的是,我得到了相当坚持早,试图证明的方式找到树中的元素对应找到它在其序遍历的方式(当然,我还需要做的序遍历) .任何想法都会受到欢迎.我对完整的解决方案并不特别感兴趣 - 更多的是帮助我们开始正确的方向.

特定

data Tree a = Tip
            | Node (Tree a) a (Tree a)

我可以通过至少两种方式将其转换为列表:

inorder : Tree a -> List a
inorder Tip = []
inorder (Node l v r) = inorder l ++ [v] ++ inorder r

要么

foldrTree : (a -> b -> b) -> b -> Tree a -> b
foldrTree c n Tip = n
foldrTree c n (Node l v r) = foldr c (v `c` foldrTree …