小编dfe*_*uer的帖子

有没有办法合法地隐藏它？我真的需要一个答案.所以,请赐教.

谁是stackoverflow.com的信息

注册人:

Jeff Atwood
410 Clayton Ave
El Cerrito,California 94530,United States注册:GoDaddy.com,Inc.(http://www.godaddy.com)域名:STACKOVERFLOW.COM
创建时间:26-Dec-03
到期日期: 26-Dec-14
最后更新时间:2008年4月13日

http://hackage.haskell.org/package/base-4.6.0.1/docs/src/GHC-Base.html#assert似乎定义assert为无操作.在启用断言时,将其转换为其他内容的逻辑在哪里？

大多数数学学生和Haskeller都熟悉的欧几里德分裂定理表明了这一点

给定两个整数a和b,其中b≠0,存在唯一的整数q和r,使得a = bq + r和0≤r<| b |.

这给出了商和余数的常规定义.这篇1992年的论文认为它们是用编程语言实现的最好的.那么,为什么divMod总是将红利转向负无穷大？

div和quot之间的确切差异表明divMod已经做了相当多的额外工作quotRem; 它似乎不太可能更难以正确.

码

我根据实现编写了以下欧几里德式divMod的实现GHC.Base.我很确定这是对的.

divModInt2 :: Int -> Int -> (Int, Int)
divModInt2 (I# x) (I# y) = case (x `divModInt2#` y) of
                        divModInt2# :: Int# -> Int# -> (# Int#, Int# #)

x# `divModInt2#` y#
 | (x# <# 0#) = case (x# +# 1#) `quotRemInt#` y# of
                    (# q, r #) -> if y# <# …

我在看如何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 …

回到那天，我虽然明白了call/cc。这些天我看到了更多对“分隔”延续运算符的引用，它们似乎成对出现，如shift/ reset、prompt/ control，有时还有更奇特的。但我还没有看到任何基础知识的明确解释，所以

1. 他们在做什么？
2. 它们是为了什么？
3. 什么可能使一组运算符比另一组更适合特定语言/上下文/目的？

有人可以帮助我理解Wadler题为" 理解Monads " 的论文中的以下定义吗？(摘录自第3.2节/第9页,即"Strictness Monad"小节.)

有时需要在惰性函数程序中控制评估顺序.这通常通过可计算函数strict来实现,定义为

严格 f x =如果x ≠⊥则f x否则⊥.

在操作上,严格 ˚F X是通过首先减少降低X弱头正常形式(WHNF),然后还原应用˚F X.或者,可以安全地并行减少x和f x,但在x处于WHNF 之前不允许访问结果.

在论文中,我们还没有看到使用由两条垂直线组成的符号(不确定它叫什么)所以它有点无处不在.

鉴于Wadler继续说"我们将使用[严格]理解来控制懒惰程序的评估",这似乎是一个非常重要的概念.

我正在玩类型对齐的序列,特别是我正在搞乱折叠它们的想法.可折叠的类型对齐序列看起来像这样:

class FoldableTA fm where
  foldMapTA :: Category h =>
                (forall b c . a b c -> h b c) ->
                fm a b d -> h b d
  foldrTA :: (forall b c d . a c d -> h b c -> h b d) ->
             h p q -> fm a q r -> h p r
  foldlTA :: ...

通过首先使用以天真的方式将序列转换为类型对齐的列表(即,使用类型对齐的列表类别)然后折叠该列表,实现foldrTA起来非常容易.不幸的是,这可能是非常低效的,因为长列表可以预先设置为短列表.我一直试图找出一种方法来使用类似于用于更有效地定义右和左折叠的技巧,但这些类型让我头晕目眩.这似乎不够通用,我从其他方向采取的每一步都会让我得到更多的类型变量,而不是我能追踪到的.foldMapTAfoldMapTAData.FoldableEndo

我刚写了一个函数(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实例.

这是我在各种编程语言中无数次使用过的模式:

1. 遇到一个问题,可以很容易地简化为一些图算法.
2. 定义邻接函数:outEdges :: MyNode -> [MyNode].
3. 编码所述图算法的一些通用形式,该算法将该函数作为其第一个参数.

例如,考虑这种(有目的效率低下)的方法来计算两个单词之间的编辑距离.我们将计算通过广度优先搜索将一个单词转换为另一个单词所需的最少插入和删除次数.

import Data.List
import Data.Maybe

alphabet :: String
alphabet = ['a'..'z']

wordNeighbors :: String -> [String]
wordNeighbors word = deletions ++ insertions where
    insertions = [pre++[c]++suf | (pre,suf) <- splits, c <- alphabet]
    deletions =  [pre++suf      | (pre,_:suf) <- take (length word) splits]

    splits = zip (inits word) (tails word)

shortestDistance :: (Eq a,Hashable a)=> (a -> [a]) -> a -> a -> Maybe Int
shortestDistance …

假设我有

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
  | …