小编dfe*_*uer的帖子

我刚写了一个函数(for Data.Sequence)

traverseWithIndex :: Applicative f => (Int -> a -> f b) -> Seq a -> f (Seq b)

哪个应该服从

traverseWithIndex f = sequenceA . mapWithIndex f

值得庆幸的是,这是一个直接的机械修改源mapWithIndex,所以我非常有信心它是正确的.但是,在更复杂的情况下,需要进行彻底的测试.我正在尝试编写一个QuickCheck属性来测试这个简单的属性.显然,我不能尝试每个Applicative仿函数!在测试幺半群时,使用某种类型的自由幺半群(即有限列表)进行测试是很有意义的.所以在这里用免费的applicative functor测试一些仿函数似乎是明智的.有两个困难:

1. 如何选择合适的基础仿函数？我可能想要一个不适用或可穿越的讨厌或任何东西,但这样的事情似乎很难处理.

2. 我如何比较结果？它们将具有功能,因此它们没有Eq实例.

假设我有

data Foo p =
    NoFoo
  | YesFoo (forall a. p a)

我可以写

fromFoo :: Foo p -> Maybe (p a)
fromFoo NoFoo = Nothing
fromFoo (YesFoo p) = Just p

它也可以走另一条路:

toFoo :: forall p.
         (forall a. Maybe (p a))
      -> Foo p
toFoo m =
  case m :: Maybe (p ()) of
    Nothing -> NoFoo
    Just _ -> YesFoo (fromJust m)

该fromJust是恶心!toFoo实际上是总数,因为参数确保m @a行为完全相同m @(),但这是粗略的.有没有更干净的方式？

编辑:rampion指出,这可以写得更简洁,仍然有fromJust.我刚刚意识到它可以做得有点幽默,取笑新手:

toFoo m
  | …

假设我需要遍历列表或树来读取(但不能修改)数据.我可以使用迭代器或拉链.是否Zipper有任何优势除了在这种情况下不可改变？

我最近添加了一个alterF函数Data.Map,这是一个翻转形式Control.Lens.At.at.

alterF :: (Ord k, Functor f)
       => (Maybe a -> f (Maybe a))
       -> k
       -> Map k a
       -> f (Map k a)

alterF被设计为能够提供合理的性能,即使对于非常"沉重"的仿函数[],甚至当密钥相当昂贵时也是如此.不幸的是,它比一个轻量级算子和便宜比较键的更常见情况下的速度慢一些.

为了解决这个问题,我为这些Const b和Identity仿函数添加了GHC重写规则,将它们重写为通常更快的更简单的实现.我准备添加另一个,因为(,) b.我添加了一个(,) b然后将其删除.请参阅下面的更新.

但是,我对我需要一个特定规则的事实感到有些恼火(,) b,因为还有许多其他仿函数遵循相同的模式.特别是,任何时候定义仿函数

data F b1 b2 ... a = F e1 ... a ... e_n

在没有e_k提及的地方a,我应该能够以同样的方式重写它.有没有办法用GHC做到这一点RULES？或者我将不得不等待更一般的重写系统？

更新

可悲的是,我意识到我对对的重写规则是无效的(它太严格了),并且修复使得它不那么明显有益.所以我现在已经取消了这条规则.不过,我认为一般性问题仍然很有意思.

据我了解，表达某事物是自由幺半群的一种方法是使用这样的类：

class (Foldable s, forall a. Monoid (s a)) => Sequence s where
  singleton :: a -> s a

以及以下“通用建筑”法律：

对于任何Monoid m和任何函数f :: a -> m，

1. foldMap f . singleton = f
2. foldMap f 是幺半群态射。
3. foldMap f 是唯一同时满足 1 和 2 的函数。

这种理解是否正确？

如果是这样，能够使用这些定律来证明基本的序列属性会很好。我们可以定义

data ViewL s a
  = EmptyL
  | a :< s a

instance Sequence s => Semigroup (ViewL s a) where
  EmptyL <> y = y
  x <> EmptyL = x
  (x :< …

我正在尝试访问主机并拥有以下代码

if(!InetAddress.getByName(host).isReachable(TIMEOUT)){
   throw new Exception("Host does not exist::"+ hostname);
 }

我可以从Windows ping主机名,并在其上执行tracert并返回所有数据包.但java抛出异常"Host is not exists ::";

从实现2000ms到5000ms的超时值.我也试过3000.我无法理解这个问题的原因是什么.我在网上研究过,有人说InetAddress.getByName(host).isReachable(time)不可靠,并且根据内部系统行事.

如果这是真的,最好的选择是什么.请建议.

最近我选择了Haskell.我发现我在Haskell中递归写入的一些基本数学算法实际上运行得更快,所以我想尝试一下.

我个人环顾四周,我找不到类似于pylab的库和Haskell的scipy.有没有人知道类似于它的东西或其他可能有用的数学库？

我所做的所有数学问题都与非线性常微分方程和偏微分方程有关,如果这有助于某人指出我的方向.

基本上是一个具有矩阵,图形,三角形,指数函数等的库.

I am writing a program where I need to check three states: 1. If I have no WiFi, 2. if I have WiFi but no internet connection (like if I turn on my router but unplug the Ethernet cable), and 3. if I have WiFi and internet connection. I would then change color of a icon in my app to represent one of these states (red, yellow, or green). Currently condition 2 does not work, anytime I unplug the cable …

一个最近的问题使我想知道如何转换

forall f . Functor f => [LensLike f s t a b]

进入

[ReifiedLens s t a b]

通过索引到列表中!!,有一种简单的方法可以非常缓慢地完成它,但它的效率非常低.感觉应该有足够的参数来拉动类似于使用的技巧reflection,但我似乎无法弄明白.是否有可能有效地完成这项工作？

Okasaki 的Purely Functional Data Structures 中描述的偏斜二项式堆支持在最坏情况下合并O(log (max (m,n)))，其中m和n是要合并的队列的长度。这比在最坏情况下支持它的分段二项式队列和在最坏情况下O(log (min (m,n)))支持它O(log (max (m,n)))但O(log (min (m,n)))分摊时间 [*] 的惰性二项式队列更糟糕。这似乎是队列表示中的偏斜二进制数采用规范形式（只有一个 2，并且仅作为最低有效非零数字）的限制所固有的。是否可以稍微放宽此限制以获得更有效的合并？基本挑战是不允许 2 级联到另一个 2。

[*] 我最近还提出了一种调度二项式队列的变体，其最坏情况边界与分段队列相同；该版本尚未完全实施。